【数据结构刷题专题】—— 二叉树

二叉树

二叉树刷题框架
在这里插入图片描述
二叉树的定义：

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL);
};

1 二叉树的遍历方式

【1】前序遍历

class Solution {
public:
    void traversal(TreeNode* node, vector<int>& vec) {
        if (node == NULL) return;
        vec.push_back(node->val);
        traversal(node->left, vec);
        traversal(node->right, vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

【2】后序遍历

class Solution {
public:
    void traversal(TreeNode* node, vector<int>& vec) {
        if (node == NULL) return;
        traversal(node->left, vec);
        traversal(node->right, vec);
        vec.push_back(node->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

【3】中序遍历

class Solution {
public:
    void traversal(TreeNode* node, vector<int>& vec) {
        if (node == NULL) return;
        traversal(node->left, vec);
        vec.push_back(node->val);
        traversal(node->right, vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

【4】层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            vector<int> vec;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

2 二叉树的属性

【1】101. 对称二叉树

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if (left != NULL && right == NULL) return false;
        else if (left == NULL && right != NULL) return false;
        else if (left == NULL && right == NULL) return true;
        else if (left->val != right->val) return false;
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        return outside && inside;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

【2】104. 二叉树的最大深度
迭代法:

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            depth++;
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

递归法：

class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == NULL) return 0;
        int left = getDepth(node->left);
        int right = getDepth(node->right);
        return 1 + max(left, right);
    }
    int maxDepth(TreeNode* root) {
        return getDepth(root);
    }
};

【3】111.二叉树的最小深度
递归法：

class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == NULL) return 0;
        int left = getDepth(node->left);
        int right = getDepth(node->right);
        if (node->left != NULL && node->right == NULL) return 1 + left;
        if (node->left == NULL && node->right != NULL) return 1 + right;
        return 1 + min(left, right);
    }
    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

迭代法：

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root == NULL) return 0;
        que.push(root);
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++;
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (node->left == NULL && node->right == NULL) return depth;
            }
        }
        return depth;
    }
};

【4】222. 完全二叉树的节点个数
递归法：

class Solution {
public:
    int getNum(TreeNode* node) {
        if (node == NULL) return 0;
        int left = getNum(node->left);
        int right = getNum(node->right);
        return 1 + left + right;
    }
    int countNodes(TreeNode* root) {
        return getNum(root);
    }
};

迭代法：

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        if (root == NULL) return 0;
        que.push(root);
        int num = 0;
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                num++;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return num;
    }
};

【5】110. 平衡二叉树

class Solution {
public:
    int getHeight(TreeNode* node) {
        if (node == NULL) return 0;
        int left = getHeight(node->left);
        if (left == -1) return -1;
        int right = getHeight(node->right);
        if (right == -1) return -1;
        return abs(left - right) > 1 ? -1 : 1 + max(left, right);
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};

【6】257. 二叉树的所有路径

class Solution {
public:
    void traversal(TreeNode* node, string path, vector<string>& result) {
        path += to_string(node->val);
        if (node->left == NULL && node->right == NULL) {
            result.push_back(path);
            return;
        }
        if (node->left) traversal(node->left, path + "->", result);
        if (node->right) traversal(node->right, path + "->", result);
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        string path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;
    }
};

【7】404. 左叶子之和

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if (root == NULL) return 0;
        int left = sumOfLeftLeaves(root->left);
        if (root->left && root->left->left == NULL && root->left->right == NULL) {
            left = root->left->val;
        }
        int right = sumOfLeftLeaves(root->right);
        return left + right;
    }
};

【8】513. 找树左下角的值
迭代法：

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        que.push(root);
        int val = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == 0) val = node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return val;
    }
};

【9】112. 路径总和

class Solution {
public:
    bool pathSum(TreeNode* node, int count) {
        if (node->left == NULL && node->right == NULL && count == 0) return true;
        if (node->left == NULL && node->right == NULL) return false;
        if (node->left) {
            count -= node->left->val;
            if (pathSum(node->left, count)) return true;
            count += node->left->val;
        }
        if (node->right) {
            count -= node->right->val;
            if (pathSum(node->right, count)) return true;
            count += node->right->val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL) return false;
        return pathSum(root, targetSum - root->val);
    }
};

【10】543. 二叉树的直径

class Solution {
public:
    int ans;
    int Depth(TreeNode* node) {
        if (node == NULL) return 0;
        int left = Depth(node->left);
        int right = Depth(node->right);
        ans = max(ans, 1 + left + right);
        return 1 + max(left, right);
    }
    int diameterOfBinaryTree(TreeNode* root) {
        ans = 1;
        Depth(root);
        return ans - 1;
    }
};

【11】124. 二叉树中的最大路径和

class Solution {
public:
    int ans = INT_MIN;
    int dfs(TreeNode* node) {
        if (node == NULL) return 0;
        ans = max(ans, node->val);
        int lSum = dfs(node->left);
        int rSum = dfs(node->right);
        lSum = max(0, lSum); rSum = max(0, rSum);
        ans = max(ans, node->val + lSum + rSum);
        return max(node->val + lSum, node->val + rSum);
    }
    int maxPathSum(TreeNode* root) {
        ans = max(ans, dfs(root));
        return ans;
    }
};

3 二叉树的修改和构造

【1】226. 翻转二叉树

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);
        if (root->left) invertTree(root->left);
        if (root->right) invertTree(root->right);
        return root;
    }
};

【2】106. 从中序与后序遍历序列构造二叉树

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) return NULL;
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (postorder.size() == 1) return root;
        int qiege;
        for (qiege = 0; qiege <= inorder.size(); qiege++) {
            if (inorder[qiege] == root->val) break;
        }
        vector<int> leftInorder(inorder.begin(), inorder.begin() + qiege);
        vector<int> rightInorder(inorder.begin() + qiege + 1, inorder.end());
        postorder.resize(postorder.size() - 1);
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};

【3】654. 最大二叉树
构造树一般采用的是前序遍历

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left >= right) return NULL;
        int index = left;
        for (int i = left + 1; i < right; i++) {
            if (nums[i] > nums[index]) index = i;
        }
        TreeNode* root = new TreeNode(nums[index]);
        root->left = traversal(nums, left, index);
        root->right = traversal(nums, index + 1, right);
        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }
};

【4】617. 合并二叉树

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == NULL) return root2;
        if (root2 == NULL) return root1;
        root1->val += root2->val;
        root1->left = mergeTrees(root1->left, root2->left);
        root1->right = mergeTrees(root1->right, root2->right);
        return root1;
    }
};

【5】114. 二叉树展开为链表

class Solution {
public:
    void traversal(TreeNode* node) {
        if (node == NULL) return;
        traversal(node->left);
        traversal(node->right);
        TreeNode* left = node->left;
        TreeNode* right = node->right;
        node->left = NULL;
        node->right = left;
        while (node->right) node = node->right;
        node->right = right;
        return;
    }
    void flatten(TreeNode* root) {
        traversal(root);
        return;
    }
};

4 求二叉树的属性

【1】700. 二叉搜索树中的搜索

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while (root != NULL) {
            if (root->val > val) {
                root = root->left;
            } else if (root->val < val) {
                root = root->right;
            } else return root;
        }
        return root;
    }
};

【2】98. 验证二叉搜索树

class Solution {
public:
    long long maxVel = LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        bool left = isValidBST(root->left);
        if (root->val > maxVel) maxVel = root->val;
        else return false;
        bool right = isValidBST(root->right);
        return left && right;
    }
};

【3】530. 二叉搜索树的最小绝对差
遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值
把二叉搜索树转换成有序数组，然后遍历一遍数组，就统计出来最小差值

class Solution {
public:
    vector<int> vec;
    int ans = INT_MAX;
    void traversal(TreeNode* node) {
        if (node == NULL) return;
        traversal(node->left);
        vec.push_back(node->val);
        traversal(node->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        for (int i = 1; i < vec.size(); i++) {
            ans = min(ans, vec[i] - vec[i - 1]);
        }
        return ans;
    }
};

在递归中记录前一个节点的指针

class Solution {
public:
    int result = INT_MAX;
    TreeNode* pre = NULL;
    void traversal(TreeNode* node) {
        if (node == NULL) return;
        traversal(node->left);
        if (pre != NULL) result = min(result, node->val - pre->val);
        pre = node;
        traversal(node->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

【4】501. 二叉搜索树中的众数

class Solution {
public:
    void traversal(TreeNode* cur, unordered_map<int, int>& map) {
        if (cur == NULL) return;
        map[cur->val]++;
        traversal(cur->left, map);
        traversal(cur->right, map);
        return;
    }
    static bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
        return a.second > b.second;
    }
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map;
        vector<int> result;
        if (root == NULL) return result;
        traversal(root, map);
        vector<pair<int, int>> vec(map.begin(), map.end());
        sort(vec.begin(), vec.end(), cmp);
        result.push_back(vec[0].first);
        for (int i = 1; i < vec.size(); i++) {
            if (vec[0].second == vec[i].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

【5】把二叉搜索树转换为累加树

class Solution {
public:
    int pre = 0;
    void traversal(TreeNode* node) {
        if (node == NULL) return;
        traversal(node->right);
        node->val += pre;
        pre = node->val;
        traversal(node->left);

    }
    TreeNode* convertBST(TreeNode* root) {
        if (root == NULL) return root;
        traversal(root);
        return root;
    }
};

【6】230. 二叉搜索树中第K小的元素

class Solution {
public:
    int maxVel = INT_MIN;
    vector<int> vec;
    void traversal(TreeNode* node) {
        if (node == NULL) return;
        traversal(node->left);
        if (node->val > maxVel) {
            vec.push_back(node->val);
            maxVel = node->val;
        }
        traversal(node->right);
        return;
    }
    int kthSmallest(TreeNode* root, int k) {
        traversal(root);
        return vec[k - 1];
    }
};

【7】二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if (root == NULL) return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == (size - 1)) result.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

5 二叉树的公共祖先问题

【1】236. 二叉树的最近公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == p || root == q || root == NULL) return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if (left != NULL && right != NULL) return root;
        if (left != NULL && right == NULL) return left;
        else if (left == NULL && right != NULL) return right;
        else return NULL;
    }
};

【2】235. 二叉搜索树的最近公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while (root) {
            if (root->val > q->val && root->val > p->val) root = root->left;
            else if (root->val < q->val && root->val < p->val) root = root->right;
            else return root;
        }
        return NULL;
    }
};

6 二叉搜索树的修改和构造

【1】二叉搜索树的插入操作

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == NULL) {
            TreeNode* node = new TreeNode(val);
            return node;
        }
        if (root->val > val) root->left = insertIntoBST(root->left, val);
        if (root->val < val) root->right = insertIntoBST(root->right, val);
        return root;
    }
};

【2】450. 删除二叉搜索树中的节点

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == NULL) return root;
        if (root->val == key) {
            if (root->left == NULL && root->right == NULL) {
                delete root;
                return NULL;
            } else if (root->left == NULL) {
                auto tmp = root->right;
                delete root;
                return tmp;
            } else if (root->right == NULL) {
                auto tmp = root->left;
                delete root;
                return tmp;
            } else {
                TreeNode* cur = root->right;
                while (cur->left != NULL) {
                    cur = cur->left;
                }
                cur->left = root->left;
                TreeNode* tmp = root;
                root = root->right;
                delete tmp;
                return root;
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};

【3】669. 修剪二叉搜索树

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if (root == NULL) return root;
        if (root->val < low) return trimBST(root->right, low, high);
        if (root->val > high) return trimBST(root->left, low, high);
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        return root;
    }
};

【4】108. 将有序数组转换为二叉搜索树

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left > right) return NULL;
        int mid = left + (right - left) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return traversal(nums, 0, nums.size() - 1);
    }
};

二叉树刷题专题到此结束，读者对题目有更好的解答欢迎讨论。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/488592.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

[C#]winformYOLO区域检测任意形状区域绘制射线算法实现

[C#]winformYOLO区域检测任意形状区域绘制射线算法实现

【简单介绍】 Winform OpenCVSharp YOLO区域检测与任意形状区域射线绘制算法实现 在现代安全监控系统中&#xff0c;区域检测是一项至关重要的功能。通过使用Winform结合OpenCVSharp库&#xff0c;并结合YOLO&#xff08;You Only Look Once&#xff09;算法&#xff0c;我们…
阅读更多...
Maven高级（工程分模块开发，聚合于继承，版本锁定，Mavne私服的搭建和发布）【详解】

Maven高级（工程分模块开发，聚合于继承，版本锁定，Mavne私服的搭建和发布）【详解】

目录 一、Maven复习 1. Maven基本概念 1 Maven的作用 2 Maven的仓库 3 坐标的概念 2. Maven安装配置 3. Maven构建项目 4. Maven依赖管理 5. Maven依赖传递 二、工程分模块开发 1. 分模块开发介绍 2. 工程分模块示例 (1) 创建父工程 (2) 创建pojo模块步骤 (3) 创…
阅读更多...
YOLOv8改进 | 检测头篇 | 2024最新HyCTAS模型提出SAttention（自研轻量化检测头 -＞ 适用分割、Pose、目标检测）

YOLOv8改进 | 检测头篇 | 2024最新HyCTAS模型提出SAttention（自研轻量化检测头 -＞ 适用分割、Pose、目标检测）

一、本文介绍 本文给大家带来的改进机制是由全新SOTA分割模型（Real-Time Image Segmentation via Hybrid Convolutional-TransformerArchitecture Search）HyCTAS提出的一种SelfAttention注意力机制，论文中叫该机制应用于检测头当中（论文中的分割效果展现目前是最好的）。我…
阅读更多...
如何学习VBA_3.2.19:利用Shell函数运行可执行程序

如何学习VBA_3.2.19:利用Shell函数运行可执行程序

我给VBA的定义&#xff1a;VBA是个人小型自动化处理的有效工具。利用好了&#xff0c;可以大大提高自己的劳动效率&#xff0c;而且可以提高数据处理的准确度。我推出的VBA系列教程共九套和一部VBA汉英手册&#xff0c;现在已经全部完成&#xff0c;希望大家利用、学习。 如果…
阅读更多...
Java-Java基础学习（4）-多线程（2）

Java-Java基础学习（4）-多线程（2）

3.7. Lambda表达式 为什么要使用lambda表达式 避免匿名内部类定义过多&#xff1b;可以让代码看起来更简洁&#xff1b;去掉一堆没有意义的代码&#xff0c;只留下核心逻辑 属于函数式编程的概念&#xff0c;格式 (params) -> expression [表达式](params) -> statement…
阅读更多...
【教学类-44-11】20240324 杨任东竹石体 Regular（实线字体）制作的数字描字帖（AI对话大师缩略版）

【教学类-44-11】20240324 杨任东竹石体 Regular（实线字体）制作的数字描字帖（AI对话大师缩略版）

作品展示 背景需求&#xff1a; 之前有三款阿拉伯数字字体&#xff0c;但是与《幼儿用数字描字簿》字体有差异 【教学类-44-05】20240201 德彪钢笔行书&#xff08;实线字体&#xff09;制作的数字描字帖-CSDN博客文章浏览阅读396次&#xff0c;点赞6次&#xff0c;收藏5次。【…
阅读更多...
Python之Web开发中级教程----中级教程成果下载

Python之Web开发中级教程----中级教程成果下载

Python之Web开发中级教程----中级教程成果下载 到目前为止&#xff0c;中级教程已经完成。 按照一步步的教程搭建虚拟机中的环境&#xff0c;包括内容如下&#xff1a; Ubuntu操作系统搭建 Python 配置 Redis 安装配置 Python库中包括 Pip安装 Pyinstaller安装 Redis安装 Jie…
阅读更多...
strlen和sizeof

strlen和sizeof

定义 strlen 和 sizeof 是 C 语言中两个用于确定字符串或数据类型大小的常用操作符&#xff0c;但它们的工作方式和目的有所不同。下面是对这两个操作符的详细解释&#xff1a; strlen strlen 是一个库函数&#xff0c;定义在 <string.h> 头文件中。它用于计算以空字符…
阅读更多...
拥有超小型领先工艺射频微波电子元器件厂商兆讯授权世强硬创代理

拥有超小型领先工艺射频微波电子元器件厂商兆讯授权世强硬创代理

射频前端芯片在模拟芯片中&#xff0c;属于进入门槛较高、设计难度较大的细分领域&#xff0c;由于国内射频前端芯片行业起步较晚&#xff0c;其市场份额主要被外企所占据&#xff0c;而在国产化浪潮的推动下&#xff0c;上游厂商的射频前端产品及技术逐渐具备领先的竞争优势。…
阅读更多...
深度学习（三）vscode加jupyter notebook插件使用

深度学习（三）vscode加jupyter notebook插件使用

0.前言 哎呀&#xff0c;我本次的实验是在新电脑上使用的&#xff0c;之前的笔记本上的环境什么的我都是很久以前弄好了的&#xff0c;结果到了新电脑上我直接忘了是该怎么配的了&#xff0c;不过万幸&#xff0c;花了点时间&#xff0c;查查补补&#xff0c;现在总算是可以了。…
阅读更多...
论文汇总：A Closer Look at Few-shot Classification Again

论文汇总：A Closer Look at Few-shot Classification Again

文章汇总 文章是在总体上再一次地观察如何小样本领域存在的问题&#xff0c;并且发现了较为有趣的规律 1.测试误差随训练类别的数量而下降&#xff0c;而不是随每个类别的训练样本数量而下降。 2.训练算法(me&#xff1a;预训练模型)和自适应算法(me&#xff1a;预训练之后的…
阅读更多...
参展企业和专业观众均创历届新高“2024杭州国际安防展会”

参展企业和专业观众均创历届新高“2024杭州国际安防展会”

随着社会的不断发展&#xff0c;安防行业逐渐成为一个备受关注的领域。杭州作为中国的科技创新之城&#xff0c;一直以来都是安防行业的重要聚集地。本次展会的举办&#xff0c;不仅为参展企业提供了一个展示自身实力的平台&#xff0c;也为观众提供了一个了解安防行业最新技术…
阅读更多...
深度解析JVM世界：JVM内存分配

深度解析JVM世界：JVM内存分配

本篇文章的主要内容是介绍JVM内存的分配方式、JVM内存的快速分配策略、JVM的逃逸分析和堆内存的分代思想几部分内容。 请同学们认真听讲&#xff0c;面试会问到。。。 1. 内存分配 大家需要注意不分配内存的对象无法进行其他操作 JVM 为对象分配内存的过程&#xff1a;首先…
阅读更多...
[flask]http请求//获取请求体数据

[flask]http请求//获取请求体数据

import jsonfrom flask import Flask, requestapp Flask(__name__)app.route("/form1", methods["post"]) def form1():"""获取客户端请求的请求体[表单]:return:""""""获取表单数据请求url&#xff1a;&qu…
阅读更多...
[深度学习]yolov8+streamlit搭建精美界面GUI网页设计源码实现三

[深度学习]yolov8+streamlit搭建精美界面GUI网页设计源码实现三

【设计思路介绍】 为了使用YOLOv8和Streamlit搭建一个精美的界面GUI网页&#xff0c;你需要遵循几个关键步骤。以下是一个简化的流程&#xff0c;帮助你设计并实现这一目标&#xff1a; 1. 环境准备 安装YOLOv8 YOLOv8是一个先进的实时目标检测模型。你需要先下载并安装YOL…
阅读更多...
Android Studio 代理

Android Studio 代理

Android Studio的代理&#xff0c;分为两级代理&#xff1a; 1. Android Studio本身的代理&#xff0c;路径在&#xff0c;右上角&#xff0c;File->Settings->Appearance & Behavior -> System Settings -> Http Proxy&#xff0c;如图所示&#xff1a; 2. G…
阅读更多...
Mybatis中QueryWrapper的复杂查询SQL

Mybatis中QueryWrapper的复杂查询SQL

最近在使用QueryWrapper编写查询语句时发现复杂的SQL不会写。在网上找了半天&#xff0c;终于得到了点启示。在此做个记录以备忘。 我要实现的SQL是这样的&#xff1a; -- 实现这个复杂查询 -- 查询设备表 select * from oa_device where ((dev_code BSD1003 and dev_status…
阅读更多...
护眼灯有没有必要买？多款高口碑护眼台灯推荐

护眼灯有没有必要买？多款高口碑护眼台灯推荐

我发现目前仍有很多家长都忽视了环境光的重要性&#xff0c;在孩子学习的时候习惯只开家里的吸顶灯提供作业&#xff0c;但其实环境光线的不足&#xff0c;对孩子的眼镜危害是非常大的&#xff01;也有家长问护眼灯有没有必要买&#xff1f; 我认为是很有必要的&#xff01;因…
阅读更多...
基于java+SpringBoot+Vue的乐校园二手书交易管理系统设计与实现

基于java+SpringBoot+Vue的乐校园二手书交易管理系统设计与实现

基于javaSpringBootVue的乐校园二手书交易管理系统设计与实现 开发语言: Java 数据库: MySQL技术: SpringBoot MyBatis工具: IDEA/Eclipse、Navicat、Maven 系统展示 前台展示 后台展示 系统简介 整体功能包含&#xff1a; 乐校园二手书交易管理系统是一个基于互联网的二…
阅读更多...
纹理压缩算法

纹理压缩算法

一、什么是纹理压缩 我们知道游戏中对于3D物体表面细节的表现最重要的还是靠贴图来实现的&#xff0c;那么越是高分辨率越是真彩色的贴图自然表现力也是越强&#xff0c;但是同时带来的问题是所需占用的内存会成倍的上升&#xff0c;而节省内存这一点在目前的游戏中还是非常非…
阅读更多...
最新文章

Copyright @ 2022~2023