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

二叉树

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

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);}
};

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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

CI/CD 搭建jenkins基础测试环境构建项目（一）

CI/CD 搭建jenkins基础测试环境构建项目（一）

Jenkins是一个开源的持续集成工具&#xff0c;可以帮助开发团队自动化构建、测试和部署他们的软件项目。通过Jenkins&#xff0c;开发团队可以实现快速、高效地交付软件&#xff0c;并及时发现和解决问题&#xff0c;从而提高团队的生产力和软件质量。持续集成/持续交付&#x…
阅读更多...
后端常问面经之操作系统

后端常问面经之操作系统

请简要描述线程与进程的关系,区别及优缺点&#xff1f; 本质区别&#xff1a;进程是操作系统资源分配的基本单位&#xff0c;而线程是任务调度和执行的基本单位 在开销方面&#xff1a;每个进程都有独立的代码和数据空间&#xff08;程序上下文&#xff09;&#xff0c;程序之…
阅读更多...
计算机网络面试题二

计算机网络面试题二

1.什么是计算机网络拓扑结构&#xff1f;计算机网络拓扑结构有哪五种基本形式&#xff1f; 计算机网络的拓扑结构是指网络中各个结点之间相互连接的几何形式。计算机网络拓扑结构的基本形式有&#xff1a;总线型网络、环形网络、星形网络、树形网络、网状网络。 2.什么是协议…
阅读更多...
【【嵌入式开发 Linux 常用命令系列 1.4 -- grep -Ev 反向搜索】

【【嵌入式开发 Linux 常用命令系列 1.4 -- grep -Ev 反向搜索】

文章目录 grep 的反向搜索 grep 的反向搜索 如果想从文件 a 中过滤掉包含字符串 “dash” 或 “tom” 的行&#xff0c;并将剩余的行写入到文件 b&#xff0c;可以使用 grep 命令配合正则表达式。使用 grep 的 -E 选项允许你指定一个扩展的正则表达式&#xff0c;而 -v 选项使…
阅读更多...
C# 中Linq并行查询AsParallel 方法与Stopwatch类的理解与使用

C# 中Linq并行查询AsParallel 方法与Stopwatch类的理解与使用

AsParallel 是 C# 中的一个方法&#xff0c;它属于 System.Linq 命名空间下的 ParallelEnumerable 类。这个方法用于启用查询的并行执行。当你对一个数据集合执行 LINQ 查询时&#xff0c;通常这些查询是按顺序执行的。但是&#xff0c;当你调用 AsParallel 方法后&#xff0c;…
阅读更多...
sql中添加数据的命令

sql中添加数据的命令

SQL&#xff0c;全称是结构化查询语言&#xff08;Structured Query Language&#xff09;&#xff0c;是一种特殊目的的编程语言&#xff0c;主要用于数据库查询和程序设计。它允许用户存取数据、查询、更新和管理关系数据库系统。SQL是高级的非过程化编程语言&#xff0c;允许…
阅读更多...
详解多模态 AI

详解多模态 AI

2022 年 11 月&#xff0c;OpenAI 推出了 ChatGPT。它只用了几天时间就以其前所未有的能力席卷了世界。生成式人工智能革命已经开始&#xff0c;每个人都在问同一个问题&#xff1a;下一步是什么&#xff1f; 当时&#xff0c;ChatGPT 和许多其他由大型语言模型 &#xff08;L…
阅读更多...
Acer宏碁暗影骑士擎AN515-58笔记本电脑工厂模式原厂Win11系统ISO镜像安装包下载

Acer宏碁暗影骑士擎AN515-58笔记本电脑工厂模式原厂Win11系统ISO镜像安装包下载

宏基AN515-58原装出厂OEM预装Windows11系统工厂包&#xff0c;恢复出厂时开箱状态一模一样&#xff0c;带恢复还原功能 链接&#xff1a;https://pan.baidu.com/s/1iCVSYtList-hPqbyTyaRqQ?pwdt2gw 提取码&#xff1a;t2gw 宏基原装系统自带所有驱动、NITROSENSE风扇键盘灯…
阅读更多...
4.2 循环语句loop，等差数列求和

4.2 循环语句loop，等差数列求和

汇编语言 1. 循环语句loop loop指令的格式是&#xff1a;loop 标号&#xff0c;CPU执行loop指令的时候&#xff0c;要进行两部操作 cx cx - 1;判断cx中的值&#xff0c;不为0则转至标号处执行程序&#xff0c;如果为0则向下执行 循环使用loop来实现&#xff0c;循环次数存…
阅读更多...
一文看尽Mac上运行Windows的所有可能：虚拟机、云电脑 更多

一文看尽Mac上运行Windows的所有可能：虚拟机、云电脑 更多

需求背景 大学期间我一直用的是windows，经历了从wind8到wind11的时代。 21年我转型干了产品，拿着surface、Thinkpad办公，生产力跟身边MacBook的同事相比大打折扣；于是我入手了一款macbook。一用上就回不了头，苹果的妙控键盘、触摸板真的是梦幻的办公组合。我本人也没有在…
阅读更多...
04、Lua 数据类型

04、Lua 数据类型

Lua 数据类型 Lua 数据类型nil&#xff08;空&#xff09;boolean&#xff08;布尔&#xff09;number&#xff08;数字&#xff09;string&#xff08;字符串&#xff09;table&#xff08;表&#xff09;function&#xff08;函数&#xff09;thread&#xff08;线程&#xf…
阅读更多...
目标跟踪研究

目标跟踪研究

我以前以为是靠高帧率实现目标识别的，现在才意识到目标跟踪也扮演着重要的角色 目录 1.目标跟踪问题简述2. 目标追踪综述3.目标跟踪-匈牙利匹配4.目标追踪-距离计算5.待续1.目标跟踪问题简述 目标跟踪 要实现跟踪，也就是需要了解前后帧之间的关系，那自然需要一个队列来保存…
阅读更多...
vue中动态路由是什么该如何实现

vue中动态路由是什么该如何实现

在 Vue 中&#xff0c;动态路由是指根据不同的参数或条件&#xff0c;生成不同的路由配置。实现动态路由可以通过以下步骤&#xff1a; 1. **定义动态路由规则**&#xff1a; - 在路由配置文件&#xff08;通常是 router/index.js&#xff09;中&#xff0c;使用路由的 pat…
阅读更多...
Typora结合PicGo + Github搭建个人图床

Typora结合PicGo + Github搭建个人图床

目录 一 、GitHub仓库设置 1、新建仓库 2、创建Token 并复制保存 二、PicGo客户端配置 1、下载 & 安装 2、配置图床 三、Typora配置 一 、GitHub仓库设置 1、新建仓库 点击主页右上角的 号创建 New repository 填写仓库信息 2、创建Token 并复制保存 点击右上角…
阅读更多...
神经网络深度学习梯度下降算法优化

神经网络深度学习梯度下降算法优化

【神经网络与深度学习】以最通俗易懂的角度解读[梯度下降法及其优化算法]&#xff0c;这一篇就足够&#xff08;很全很详细&#xff09;_梯度下降在神经网络中的作用及概念-CSDN博客 https://blog.51cto.com/u_15162069/2761936 梯度下降数学原理
阅读更多...
JavaSE（上）-Day10

JavaSE（上）-Day10

JavaSE&#xff08;上&#xff09;-Day10 多态多态中成员变量的调用多态中成员方法的调用多态的优缺点 包final关键字权限访问修饰符代码块 多态 什么是多态&#xff1a;对象的多种形态多态的前提是&#xff1a;有继承或实现关系&#xff1b;子类重写父类的方法&#xff0c;父…
阅读更多...
QGraphicsView实现图片放大、缩小、鼠标拖动、以鼠标点放大缩小

QGraphicsView实现图片放大、缩小、鼠标拖动、以鼠标点放大缩小

1. 工程配置文件 pro 1 QT core gui2 3 greaterThan(QT_MAJOR_VERSION, 4): QT widgets4 5 CONFIG c116 7 # The following define makes your compiler emit warnings if you use8 # any Qt feature that has been marked deprecated (the exact warnings9 # depend…
阅读更多...
使用免费ChatGPT提升工作效率

使用免费ChatGPT提升工作效率

ChatGPT无限次数: 点击直达 智能工作利器ChatGPT&#xff1a;提升工作效率 在当今信息爆炸的时代&#xff0c;快速高效地撰写论文对于科研工作者来说至关重要。智能工具ChatGPT的出现为我们提供了强大的支持&#xff0c;它不仅能够提升工作的效率&#xff0c;还能够帮助我们更…
阅读更多...
Oracle 使用PLSQL 导出 一个表的insert 语句

Oracle 使用PLSQL 导出 一个表的insert 语句

1. 使用工具 plsql 的方法,如图示 2. 操作界面(按ctrl键鼠标可多选表) 3. 然后就看到了插入语句 原文&#xff1a;https://www.cnblogs.com/jinanxiaolaohu/p/9192766.html
阅读更多...
基于直方图相似性的图像分类算法FPGA实现,包括tb测试文件和MATLAB辅助验证

基于直方图相似性的图像分类算法FPGA实现,包括tb测试文件和MATLAB辅助验证

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程 1.算法运行效果图预览 MATLAB测试结果&#xff1a; FPGA测试结果&#xff1a; 上述仿真图中&#xff0c;红色XX表示图像读取完毕。因此输出XX。当图像输出完成之后&…
阅读更多...
最新文章

Copyright @ 2022~2023