代码随想录算法训练营第十三天 | 第六章二叉树-理论基础，递归遍历，迭代遍历，统一迭代

news2024/9/22 13:29:35

一、参考资料

二叉树理论基础

文章讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

递归遍历

题目链接/文章讲解/视频讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%80%92%E5%BD%92%E9%81%8D%E5%8E%86.html

迭代遍历

题目链接/文章讲解/视频讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%BF%AD%E4%BB%A3%E9%81%8D%E5%8E%86.html

统一迭代

题目链接/文章讲解：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E7%BB%9F%E4%B8%80%E8%BF%AD%E4%BB%A3%E6%B3%95.html

二、二叉树理论基础

https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

二叉树的存储方式：链式存储和顺序存储。

二叉树主要有两种遍历方式：

  1. 深度优先遍历：先往深走，遇到叶子节点再往回走。

  1. 广度优先遍历：一层一层的去遍历。

  • 深度优先遍历

  • 前序遍历（递归法，迭代法） 中左右

  • 中序遍历（递归法，迭代法） 左中右

  • 后序遍历（递归法，迭代法） 左右中

  • 广度优先遍历

  • 层次遍历（迭代法）

三、递归遍历

递归算法的三个要素：
1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

    • 144.二叉树的前序遍历(opens new window)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 // version_1：递归方式，声明数组引用，在方法内部进行调用
class Solution {
public:
    // 二叉树的前序遍历
    void traversal (TreeNode *cur, vector<int> &res) {
        // 第一步，确定递归函数的参数和返回值
        // 第二步，确定终止条件
        // 第三步，确定单层递归的逻辑
        if (cur == NULL) return;
        res.push_back(cur->val);   // 中
        traversal(cur->left, res); // 左
        traversal(cur->right, res);// 右
    }
    // 主函数调用前序遍历函数，返回前序遍历的结果数组
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 // version_2：递归方式，声明全局数组
class Solution {
private:
    vector<int> res;
public:
    // 二叉树的前序遍历
    void traversal (TreeNode *cur) {
        // 第一步，确定递归函数的参数和返回值
        // 第二步，确定终止条件
        // 第三步，确定单层递归的逻辑
        if (cur == NULL) return;
        res.push_back(cur->val);   // 中
        traversal(cur->left); // 左
        traversal(cur->right);// 右
    }
    // 主函数调用前序遍历函数，返回前序遍历的结果数组
    vector<int> preorderTraversal(TreeNode* root) {
        traversal(root);
        return res;
    }
};

    • 145.二叉树的后序遍历(opens new window)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal (TreeNode *cur, vector<int> &res) {
        if (cur == NULL) return;
        traversal(cur->left, res);
        traversal(cur->right, res);
        res.push_back(cur->val);
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};

    • 94.二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal(TreeNode *cur, vector<int> &res) {
        if (cur == NULL) return ;
        traversal(cur->left, res);
        res.push_back(cur->val);
        traversal(cur->right, res);
    }

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }
};

四、迭代遍历

    • 144.二叉树的前序遍历(opens new window)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 // version_3：非递归方式
class Solution {
public:
    // 注意代码中空节点不入栈
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while(!st.empty()) {
            TreeNode* node = st.top();   //中
            st.pop();
            result.push_back(node->val);
            if (node->right) st.push(node->right);  //右
            if (node->left)  st.push(node->left);   //左
        }
        return result;
    }
};

    • 145.二叉树的后序遍历(opens new window)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;
        if(root == NULL) return res;
        st.push(root);
        while(!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            res.push_back(node->val);
            if (node->left) st.push(node->left);
            if (node->right) st.push(node->right);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void swap(int &a, int &b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
    // 手动实现数组反转
    vector<int> reverse(vector<int> res) {
        int i = 0;
        int j = res.size() - 1;
        while (i < j) {
            swap(res[i], res[j]);
            i++;
            j--;
        }
        return res;
    }
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;
        if(root == NULL) return res;
        st.push(root);
        while(!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            res.push_back(node->val);
            if (node->left) st.push(node->left);
            if (node->right) st.push(node->right);
        }
        // reverse(res.begin(), res.end());
        res = reverse(res);
        return res;
    }
};

    • 94.二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 
 // 中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
                st.pop();
                result.push_back(cur->val);     // 中
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

五、统一迭代

    • 144.二叉树的前序遍历(opens new window)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // version_4：非递归方式 —— 统一迭代法
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);
                if (node->left) st.push(node->left);

                st.push(node);
                st.push(NULL);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};

    • 94.二叉树的中序遍历(opens new window)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
// version_4：非递归方式 —— 统一迭代法
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();   // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);   // 添加右节点（空节点不入栈）

                st.push(node);  // 添加中节点
                st.push(NULL);  // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);      // 添加左节点（空节点不入栈）
            } else {   // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();        // 将空节点弹出
                node = st.top(); // 重新取出栈中元素
                st.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                res.push_back(cur->val);
                cur = cur->right;
            }
        }
        return res;
    }
};

    • 145.二叉树的后序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();

                st.push(node);
                st.push(NULL);

                if (node->right) st.push(node->right);
                if (node->left) st.push(node->left);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};

补博客！

刷题加油鸭~~

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

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

相关文章

Mobilenet v1-v3

Mobilenet v1-v3

MobileNet V1 理解 MobileNetV1的关键是理解深度可分离卷积 深度可分离卷积 Depthwise Separable Conv 深度可分离卷积单通道卷积&#xff08;提取特征&#xff09;逐点卷积&#xff08;增加维度&#xff09; 普通卷积 输入一个 12123 的一个输入特征图&#xff0c;经过256…
阅读更多...
微服务/分布式初始

微服务/分布式初始

1.单体服务架构的特点 当服务单一、规模小、逻辑简单时&#xff0c;用一个单体服务就挺 单体服务的缺点 复杂程度高。维护成本越来越高&#xff0c;各个模块之间边界模糊&#xff0c;一个模块的改动可能导致整个服务出现问题&#xff0c;一点内存泄漏、一处指针错误就会让整…
阅读更多...
汉诺塔+汉诺四塔（C/C++）

汉诺塔+汉诺四塔（C/C++）

目录 汉诺塔 1 简介 2 代码思路 2.1 对于次数的理解 2.2 对于移动的理解 3 代码 4 加深理解 汉诺四塔 1 思路 2 代码 汉诺塔 1 简介 汉诺塔(Tower of Hanoi)&#xff0c;又称河内塔&#xff0c;是一个源于印度古老传说的益智玩具。大梵天创造世界的时候做了三…
阅读更多...
关于e^x的部分公式和约算方法

关于e^x的部分公式和约算方法

常用的几个不等式: ex≥x1e^{x}\geq x1ex≥x1ln⁡x≤x−1\ln x\leq x-1lnx≤x−1ex≥exe^{x} \geq exex≥exex≥1xx22e^x\geq1x\frac{x^2}{2}ex≥1x2x2​ 当x>0时&#xff0c;ex≥ex(x−1)2x2−(e−2)x1e^x\geq ex(x-1)^{2}x^2-(e-2)x1ex≥ex(x−1)2x2−(e−2)x1 上述算式在…
阅读更多...
数据库系统概论——函数依赖、码和范式（1NF、2NF、3NF、BCNF）详解

数据库系统概论——函数依赖、码和范式（1NF、2NF、3NF、BCNF）详解

文章目录概念回顾1、函数依赖的定义1.1 平凡函数依赖和非平凡函数依赖1.2 完全函数依赖和部分函数依赖1.3 传递函数依赖2、码2.1 主码和候选码2.1主属性与非主属性2.2 全码2.3 外部码3、范式3.1 第一范式&#xff08;1NF&#xff09;3.2 第二范式&#xff08;2NF&#xff09;3.…
阅读更多...
现在的互联网技术，已蜕变成区块链技术，人工智能技术

现在的互联网技术，已蜕变成区块链技术，人工智能技术

在互联网的进化过程中&#xff0c;我们看到了互联网技术的不断孪生与蝶变。现在的互联网技术&#xff0c;早已不再是传统意义上的互联网技术&#xff0c;而是蜕变成为了大数据技术&#xff0c;云计算技术&#xff0c;蜕变成为了区块链技术&#xff0c;人工智能技术。这些新的技…
阅读更多...
【STM32笔记】HAL库ADC测量精度提高方案（利用内部参考电压VREFINT计算VDDA来提高精度）

【STM32笔记】HAL库ADC测量精度提高方案（利用内部参考电压VREFINT计算VDDA来提高精度）

【STM32笔记】HAL库ADC测量精度提高方案&#xff08;利用内部参考电压VREFINT计算VDDA来提高精度&#xff09; 多数STM32的MCU 都没有内部基准电压 如L496系列 但在外接VDDA时&#xff08;一般与VCC 3.3V连接&#xff09; 有可能VCC不稳定 导致参考电压不确定 从而使ADC测量不…
阅读更多...
深度学习调参炼丹术(总结向)

深度学习调参炼丹术(总结向)

调参控制变量&#xff0c;每次调一个值。 1.初始化方式&#xff1a;FC/CNN用kaiming uniform或normalize&#xff0c;Emendding选截断normalize 2.activation function&#xff1a;sigmoid(淘汰)、tanh(淘汰)、relu(推荐)、leakey-relu 3.优化器&#xff1a;SGD动量&#xff0…
阅读更多...
若依配置教程（三）新建模块

若依配置教程（三）新建模块

若依模块化管理&#xff0c;使代码更加规范化&#xff0c;方便在不同文件夹下进行修改和开发。 接下来是新建模块的步骤&#xff1a; 文章目录**接下来是新建模块的步骤&#xff1a;**1.创建新的module2.配置pom.xml1.创建新的module 项目上鼠标右击&#xff1a; 然后修改项…
阅读更多...
Kettle 实战教程

Kettle 实战教程

Kettle 实战教程1.引言....................................................................................81.1 编写目的...........................................................81.2 阅读对象...........................................................91.3 术…
阅读更多...
DBCO-SS-Mal；DBCO二硫键-马来酰亚胺-点击化学

DBCO-SS-Mal；DBCO二硫键-马来酰亚胺-点击化学

DBCO-SS-Maleimide&#xff1b;Mal-SS-DBCO 英 文 &#xff1a;DBCO-SS-Maleimide 中文&#xff1a;二苯并环辛炔-二硫键-马来酰亚胺 分子式&#xff1a;C30H30N4O5S2 分子量&#xff1a;590.71 存储条件&#xff1a;-20C&#xff0c;避光&#xff0c;避湿 用 途&#xff…
阅读更多...
做自媒体，有哪些好用的工具和软件，这6大自媒体工具，力荐！

做自媒体，有哪些好用的工具和软件，这6大自媒体工具，力荐！

工具一&#xff1a;效率控 效率控是一个汇集很多工具的工具APP。使用它可以用来习惯养成&#xff0c;表情制作&#xff0c;二维码生成&#xff0c;倒数日&#xff0c;文字识别&#xff0c;配色方案等等。 它特别一个亮点的功能是剪切板增强&#xff0c;还有一个特别实用的功能是…
阅读更多...
DevStyle，一个让Java开发更现代化的工具！

DevStyle，一个让Java开发更现代化的工具！

如果您喜欢Eclipse的强大功能&#xff0c;但对它的可用性和美观度没有很高的要求&#xff0c;那么从今天开始&#xff0c;请准备好从全新的角度来看待Eclipse。在之前暗黑的插件基础上&#xff0c;MyEclipse官方团队为大家带来了DevStyle。使用DevStyle&#xff0c;开发人员可以…
阅读更多...
小程序提升篇-组件

小程序提升篇-组件

提升篇学习目标如何自定义小程序组件小程序组件中behaviors的作用安装和配置vant-weapp组件库如何使用MobX实现全局数据共享如何对小程序API进行Promise化小程序组件学习目标创建并引用组件&#xff08;全局、局部、usingComponent&#xff09;修改组件样式&#xff08;option-…
阅读更多...
Java JVM：字节码执行引擎（六）

Java JVM：字节码执行引擎（六）

执行引擎是 Java 虚拟机核心的组成部分之一&#xff0c;执行引擎由软件自行实现 目录一、运行时栈帧结构二、方法调用三、基于栈的字节码解释执行引擎四、OSGI&#xff1a;灵活的类加载器架构一、运行时栈帧结构 Java 虚拟机以方法作为最基本的执行单元&#xff0c;“栈帧”则…
阅读更多...
如何用ffmpeg截取视频片段 以及 截取时间不准确的坑

如何用ffmpeg截取视频片段 以及 截取时间不准确的坑

之前在工作中&#xff0c;有遇到需要程序化截取视频片段的场景&#xff0c;这里使用ffmpeg命令行就可以很容易实现&#xff0c;这里也记录下我们使用过程中遇到的坑&#xff0c;希望对大家也有所帮助。    举个例子&#xff0c;当我们要截取视频文件中input.mp4的第15秒到第9…
阅读更多...
【C语言练习】逻辑分析题

【C语言练习】逻辑分析题

目录题目一&#xff1a;求名次题目详情&#xff1a;解题思路&#xff1a;题目二&#xff1a;找凶手题目详情&#xff1a;解题思路&#xff1a;题目一&#xff1a;求名次 题目详情&#xff1a; 5位运动员参加了10米台跳水比赛&#xff0c;有人让他们预测比赛结果&#xff1a; A…
阅读更多...
(02)Cartographer源码无死角解析-(52) 2D点云扫描匹配→ceres扫描匹配:CeresScanMatcher2D→栅格地图残差

(02)Cartographer源码无死角解析-(52) 2D点云扫描匹配→ceres扫描匹配:CeresScanMatcher2D→栅格地图残差

讲解关于slam一系列文章汇总链接:史上最全slam从零开始&#xff0c;针对于本栏目讲解(02)Cartographer源码无死角解析-链接如下: (02)Cartographer源码无死角解析- (00)目录_最新无死角讲解&#xff1a;https://blog.csdn.net/weixin_43013761/article/details/127350885 文末…
阅读更多...
上海洲邦携手图扑建设数字孪生工厂，获 2022 智能制造优秀场景

上海洲邦携手图扑建设数字孪生工厂，获 2022 智能制造优秀场景

前言 12 月 2 日&#xff0c;工信部公示了 2022 年度智能制造示范工厂揭榜单位和优秀场景名单。图扑软件和上海洲邦合作建设的宁波甬友数字孪生工厂被评为优秀场景&#xff0c;全国共有 369 个智能制造典型场景入选。 《智能制造试点示范行动实施方案》包括智能制造优秀场景和…
阅读更多...
ESP-IDF:快速排序测试

ESP-IDF:快速排序测试

ESP-IDF:快速排序测试 /快速排序测试/ void printArray(int arr[], int len) { for (int i 0; i < len; i) { cout << arr[i] << " "; } cout << endl; } void QuickSort(int arr[], int start, int end) { int i start; int j end; // 找…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023