第六章 二叉树part01-下

已于 2024-06-19 15:45:27 修改
阅读量1.1k 收藏 13
点赞数 14
分类专栏： 代码随想录 文章标签： c++ 算法 数据结构 leetcode
于 2024-06-19 15:44:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a781333978/article/details/139796971
版权

二叉树的层序遍历

题目描述

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

解题思路

递归实现

沿着二叉树从上到下进行逐层遍历，每到一个新层级就往一个结果集中新增一个列表用于加入当前层的节点值。通过递归调用，它能够访问树的每一个节点，并确保每一层的节点都被集中到一个单独的列表中。这就像是逐层收集树上的果实，并把同一层的果实放在一起。

自定义队列实现

使用一个队列来按顺序访问二叉树的每个节点，同时用一个哈希表来记录每个节点的层级。遍历时，如果碰到一个新层级的节点，就在结果列表中加一个新的子列表。这样，就能一层层地把节点值收集起来，实现了二叉树的逐层遍历。简单来说，就像在排队接水，每个人（节点）按顺序来，按层级分组，确保每一层的人都能按顺序接到水。

原生队列实现

层序遍历符合BFS条件，可以直接使用一个队列来逐层遍历二叉树，每次处理一层的节点，将这些节点的值收集到一个列表中，然后再将这个列表添加到结果列表里。简单来说，就是一层一层地“剥洋葱”，每剥一层就把这层的节点值收集起来。

代码实现

测试地址：https://leetcode.cn/problems/binary-tree-level-order-traversal/

递归实现

class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        // 如果当前节点为空，则返回
        if (cur == nullptr) return;
      
        // 如果结果数组的大小等于当前深度，说明这一层还没有被访问，因此需要新增一个数组
        if (result.size() == depth) result.push_back(vector<int>());
      
        // 将当前节点的值加入对应深度的数组中
        result[depth].push_back(cur->val);
      
        // 递归遍历左子树，深度加一
        order(cur->left, result, depth + 1);
        // 递归遍历右子树，深度加一
        order(cur->right, result, depth + 1);
    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0; // 初始深度为0
        order(root, result, depth); // 从根节点开始递归遍历
        return result;
    }
};

自定义队列实现：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans; // 结果向量，用于存储每一层的节点值
        if(root != nullptr){     // 如果根节点不为空
            queue<TreeNode*> queue; // 创建一个队列，用于BFS遍历
            unordered_map<TreeNode*,int> levels; // 创建一个哈希表，用于记录每个节点的层级
            queue.push(root);     // 将根节点加入队列
            levels[root] = 0;     // 根节点的层级为0
            while(!queue.empty()){ // 当队列不为空时
                TreeNode* cur = queue.front(); // 取出队列头部的节点
                queue.pop();                   // 从队列中移除该节点
                int level = levels[cur];       // 获取当前节点的层级
                if(ans.size() == level){       // 如果结果向量的大小等于当前层级，说明需要新增一层
                    ans.push_back(vector<int>()); // 添加一个新的空向量
                }
                ans[level].push_back(cur->val); // 将当前节点的值加入到对应层级的向量中
                if(cur->left != nullptr){       // 如果当前节点有左子节点
                    queue.push(cur->left);       // 将左子节点加入队列
                    levels[cur->left] = level + 1; // 左子节点的层级为当前层级加1
                }
                if(cur->right != nullptr){      // 如果当前节点有右子节点
                    queue.push(cur->right);      // 将右子节点加入队列
                    levels[cur->right] = level + 1; // 右子节点的层级为当前层级加1
                }
            }
        }
        return ans; // 返回结果向量
    }
};

原生队列实现：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans; // 结果向量，用于存储每一层的节点值
        if (root != nullptr) {   // 如果根节点不为空
            queue<TreeNode*> queue; // 创建一个队列，用于BFS遍历
            queue.push(root);       // 将根节点加入队列
            while (!queue.empty()) { // 当队列不为空时
                int size = queue.size(); // 当前层的节点数量
                vector<int> list;        // 用于存储当前层的节点值
                for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                    TreeNode* cur = queue.front(); // 取出队列头部的节点
                    queue.pop();                   // 从队列中移除该节点
                    list.push_back(cur->val);      // 将节点值加入当前层的列表
                    if (cur->left != nullptr) {    // 如果当前节点有左子节点
                        queue.push(cur->left);     // 将左子节点加入队列
                    }
                    if (cur->right != nullptr) {   // 如果当前节点有右子节点
                        queue.push(cur->right);    // 将右子节点加入队列
                    }
                }
                ans.push_back(list); // 将当前层的节点值列表加入结果向量
            }
        }
        return ans; // 返回结果向量
    }
};

二叉树的层序遍历 II

题目描述

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

image

解题思路

和层序遍历思路类似，只需要在返回结果集前进行反转即可。

代码实现

测试地址：https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> ans; // 结果向量，用于存储每一层的节点值
        if (root != nullptr) {   // 如果根节点不为空
            queue<TreeNode*> queue; // 创建一个队列，用于BFS遍历
            queue.push(root);       // 将根节点加入队列
            while (!queue.empty()) { // 当队列不为空时
                int size = queue.size(); // 当前层的节点数量
                vector<int> list;        // 用于存储当前层的节点值
                for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                    TreeNode* cur = queue.front(); // 取出队列头部的节点
                    queue.pop();                   // 从队列中移除该节点
                    list.push_back(cur->val);      // 将节点值加入当前层的列表
                    if (cur->left ) {    // 如果当前节点有左子节点
                        queue.push(cur->left);     // 将左子节点加入队列
                    }
                    if (cur->right) {   // 如果当前节点有右子节点
                        queue.push(cur->right);    // 将右子节点加入队列
                    }
                }
                ans.push_back(list); // 将当前层的节点值列表加入结果向量
            }
        }
        reverse(ans.begin(), ans.end()); //反转结果集
        return ans; // 返回结果向量
    }
};

二叉树的右视图

题目描述

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

image

解题思路

在层序遍历的过程中，判断当前元素是否为单层的最后一个元素，如果是的话，将其加入结果集中

代码实现

测试地址：https://leetcode.cn/problems/binary-tree-right-side-view/

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que; // 创建一个队列，用于层序遍历二叉树
        if (root != nullptr) { // 如果根节点不为空
            que.push(root); // 将根节点加入队列
        }
        vector<int> ans; // 结果向量，用于存储右视图的节点值
        while (!que.empty()) { // 当队列不为空时
            int size = que.size(); // 获取当前层的节点数量
            for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                TreeNode* node = que.front(); // 取出队列头部的节点
                que.pop(); // 从队列中移除该节点
                if (i == (size - 1)) // 如果当前节点是当前层的最后一个节点
                    ans.push_back(node->val); // 将该节点的值加入结果向量
                if (node->left) // 如果当前节点有左子节点
                    que.push(node->left); // 将左子节点加入队列
                if (node->right) // 如果当前节点有右子节点
                    que.push(node->right); // 将右子节点加入队列
            }
        }
        return ans; // 返回结果向量
    }
};

二叉树的层平均值

题目描述

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

image

解题思路

在层序遍历的时候，将每层元素的总和加入到结果集中

代码实现

测试地址：https://leetcode.cn/problems/average-of-levels-in-binary-tree/

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que; // 创建一个队列，用于层序遍历二叉树
        vector<double> ans; // 结果向量，用于存储每层的平均值
        if (root != nullptr) // 如果根节点不为空
            que.push(root); // 将根节点加入队列
        while (!que.empty()) { // 当队列不为空时
            int size = que.size(); // 获取当前层的节点数量
            double sum = 0; // 用于计算当前层节点值的总和
            for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                TreeNode* node = que.front(); // 取出队列头部的节点
                que.pop(); // 从队列中移除该节点
                sum += node->val; // 将节点值加入总和
                if (node->left) // 如果当前节点有左子节点
                    que.push(node->left); // 将左子节点加入队列
                if (node->right) // 如果当前节点有右子节点
                    que.push(node->right); // 将右子节点加入队列
            }
            ans.push_back(sum / size); // 将当前层的平均值加入结果向量
        }
        return ans; // 返回结果向量
    }
};

N叉树的层序遍历

题目描述

给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。

例如，给定一个 3叉树 :

image

解题思路

和之前的思路差不多，只是一个节点有多个孩子，遍历加入队列即可。

代码实现

测试地址：https://leetcode.cn/problems/n-ary-tree-level-order-traversal/description/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que; // 创建一个队列，用于层序遍历N叉树
        vector<vector<int>> ans; // 结果向量，用于存储层序遍历的每层节点值
        if (root != nullptr) // 如果根节点不为空
            que.push(root); // 将根节点加入队列
        while (!que.empty()) { // 当队列不为空时
            int size = que.size(); // 获取当前层的节点数量
            vector<int> vec; // 用于存储当前层的节点值
            for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                Node* node = que.front(); // 取出队列头部的节点
                que.pop(); // 从队列中移除该节点
                vec.push_back(node->val); // 将节点值加入当前层的节点值向量
                // 遍历当前节点的所有子节点，并将它们加入队列
                for (int i = 0; i < node->children.size(); i++) {
                    if (node->children[i]) {
                        que.push(node->children[i]);
                    }
                }
            }
            ans.push_back(vec); // 将当前层的节点值向量加入结果向量
        }
        return ans; // 返回结果向量
    }
};

在每个树行中找最大值

题目描述

您需要在二叉树的每一行中找到最大的值。

image

解题思路

层序遍历取每层最大值加入到结果集返回即可。

代码实现

测试地址：https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que; // 创建一个队列，用于层序遍历
        vector<int> ans; // 结果向量，用于存储每层的最大值
        if (root != nullptr) // 如果根节点不为空
            que.push(root); // 将根节点加入队列
        while (!que.empty()) { // 当队列不为空时
            int size = que.size(); // 获取当前层的节点数量
            int tmp = INT_MIN; // 用于记录当前层的最大值，初始化为INT_MIN
            for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                TreeNode* cur = que.front(); // 取出队列头部的节点
                que.pop(); // 从队列中移除该节点
                tmp = max(tmp, cur->val); // 更新当前层的最大值
                if (cur->left) { // 如果当前节点有左子节点
                    que.push(cur->left); // 将左子节点加入队列，以便后续处理
                }
                if (cur->right) { // 如果当前节点有右子节点
                    que.push(cur->right); // 将右子节点加入队列
                }
            }
            ans.push_back(tmp); // 将当前层的最大值加入结果向量
        }
        return ans; // 返回结果向量
    }
};

填充每个节点的下一个右侧节点指针

题目描述

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

116.填充每个节点的下一个右侧节点指针

解题思路

通过层序遍历的方式，逐层连接树中的各个节点。在每一层中，通过一个队列来管理节点，并使用两个指针 preNode 和 node 来跟踪当前正在处理的节点和前一个节点。对于每一层的节点，首先处理第一个节点，然后依次处理后续节点，将前一个节点的 next 指针指向当前节点，实现节点间的连接。每层最后一个节点的 next 指针默认指向 NULL。

代码实现

测试地址：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que; // 使用队列进行层序遍历
        if (root != nullptr) // 如果根节点不为空，则将其加入队列
            que.push(root);
        while (!que.empty()) { // 当队列不为空时，进行遍历
            int size = que.size(); // 获取当前层的节点数量
            Node* node; // 用于指向当前处理的节点
            Node* preNode; // 用于指向前一个节点，以便连接next指针
            for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                if (i == 0) { // 如果是当前层的第一个节点
                    preNode = que.front(); // 获取队列的第一个节点作为前一个节点
                    que.pop(); // 从队列中移除已处理的节点
                    node = preNode; // 初始化当前节点为第一个节点
                } else { // 如果不是当前层的第一个节点
                    node = que.front(); // 更新当前节点为队列的第一个节点
                    que.pop(); // 从队列中移除已处理的节点
                    preNode->next = node; // 将前一个节点的next指针指向当前节点，实现连接
                    preNode = preNode->next; // 将前一个节点更新为当前节点，为下一次连接做准备
                }
                // 将当前节点的左右子节点加入队列，为下一层的遍历做准备
                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
			//本层最后一个节点指向NULL
			preNode->next = NULL;
        }
        return root;
	}
};

填充每个节点的下一个右侧节点指针 II

题目描述

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

image

解题思路

和上题没啥区别，无非是从完整二叉树变为了普通二叉树，代码和上题一样。

代码实现

测试地址：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;    // 使用队列进行层序遍历
        if (root != nullptr) // 如果根节点不为空，则将其加入队列
            que.push(root);
        while (!que.empty()) {     // 当队列不为空时，进行遍历
            int size = que.size(); // 获取当前层的节点数量
            Node* node;            // 用于指向当前处理的节点
            Node* preNode; // 用于指向前一个节点，以便连接next指针
            for (int i = 0; i < size; i++) { // 遍历当前层的所有节点
                if (i == 0) { // 如果是当前层的第一个节点
                    preNode = que.front(); // 获取队列的第一个节点作为前一个节点
                    que.pop();      // 从队列中移除已处理的节点
                    node = preNode; // 初始化当前节点为第一个节点
                } else {            // 如果不是当前层的第一个节点
                    node = que.front(); // 更新当前节点为队列的第一个节点
                    que.pop();          // 从队列中移除已处理的节点
                    preNode->next =
                        node; // 将前一个节点的next指针指向当前节点，实现连接
                    preNode =
                        preNode
                            ->next; // 将前一个节点更新为当前节点，为下一次连接做准备
                }
                // 将当前节点的左右子节点加入队列，为下一层的遍历做准备
                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
            // 本层最后一个节点指向NULL
            preNode->next = NULL;
        }
        return root;
    }
};

二叉树的最大深度

题目描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

104. 二叉树的最大深度

返回它的最大深度 3 。

解题思路

递归版

通过递归地计算左子树和右子树的深度，然后取两者中的最大值并加1（表示当前节点），从而得到以当前节点为根的树的最大深度。

迭代版

在进行层序遍历的时候记录遍历的次数，即为树的最大深度。

代码实现

测试地址：https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/

递归版实现

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

迭代版实现

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

二叉树的最小深度

题目描述

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明： 叶子节点是指没有子节点的节点。

image

解题思路

迭代版

使用层序遍历的方式，当左右孩子都为空时，说明已经遍历到最低点了，如果其中一个孩子为空，说明还能够继续遍历，不是最低点。

递归版

过递归地计算左子树和右子树的最小深度，然后取两者中的最小值并加1（表示当前节点），从而得到以当前节点为根的树的最小深度。

代码实现

测试地址：https://leetcode.cn/problems/minimum-depth-of-binary-tree/

迭代版实现

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录最小深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }
};

递归实现

class Solution {
public:
    int minDepth(TreeNode* root) {
        // 如果树为空，返回深度0
        if (root == nullptr)
            return 0;
        // 如果当前节点是叶节点，返回深度1
        if (root->left == nullptr && root->right == nullptr)
            return 1;
        // 初始化左子树和右子树的最小深度为最大值
        int ldeep = INT_MAX;
        int rdeep = INT_MAX;
        // 如果左子树存在，计算其最小深度
        if (root->left != nullptr) {
            ldeep = minDepth(root->left);
        }
        // 如果右子树存在，计算其最小深度
        if (root->right != nullptr) {
            rdeep = minDepth(root->right);
        }
        // 返回左右子树中深度较小的那个，并加1（当前节点）
        return min(ldeep, rdeep) + 1;
    }
};
C1aySec
关注
  • 14
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论(part2)
09-09
第6章 堆排序 6．1 堆 6．2 保持堆的性质 6．3 建堆 6．4 堆排序算法 6．5 优先级队列 第7章 快速排序 7．1 快速排序的描述 7．2 快速排序的性能 7．3 快速排序的随机化版本 7．4 快速排序分析 7．4．1 ...
算法导论(part1)
09-09
第6章 堆排序 6．1 堆 6．2 保持堆的性质 6．3 建堆 6．4 堆排序算法 6．5 优先级队列 第7章 快速排序 7．1 快速排序的描述 7．2 快速排序的性能 7．3 快速排序的随机化版本 7．4 快速排序分析 7．4．1 ...
第六章 二叉树part01-上
a781333978的博客
06-19 1138
使用一个队列来按顺序访问二叉树的每个节点，同时用一个哈希表来记录每个节点的层级。遍历时，如果碰到一个新层级的节点，就在结果列表中加一个新的子列表。这样，就能一层层地把节点值收集起来，实现了二叉树的逐层遍历。简单来说，就像在排队接水，每个人（节点）按顺序来，按层级分组，确保每一层的人都能按顺序接到水。public:// 结果向量，用于存储每一层的节点值if(root!= nullptr){ // 如果根节点不为空// 创建一个队列，用于BFS遍历// 创建一个哈希表，用于记录每个节点的层级。
Day14 第六章 二叉树part01-二叉树（递归遍历，迭代遍历，统一迭代）
weixin_65279006的博客
09-06 118
第一次经过一个节点时，不能直接弹出它本身，因为中序遍历要先弹出它的左节点，这时候就应该先弹出然后在压入右节点之后再将其本身再次压入，然后压入左节点，第二次经过的时候再彻底弹出。写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。4.总体思路是，首先押入根节点，然后弹出一个节点就押入它的右左节点，这样每次先弹出自己，然后弹出左，左节点弹出完了，栈不为空然后依次弹出右节点。
Day16-第六章 二叉树 part02-层序遍历，反转二叉树，对称二叉树
weixin_65279006的博客
09-07 80
1.与前中后序遍历不同的是，因为层序遍历要把一层的节点全给处理掉再进行下一层，所以需要两个循环来保证一层的节点都被处理了。简单地说，不同的遍历方法对应着不同的遍历需求，而每种数据结构（队列和栈）提供了满足这些需求的特定功能。对于DFS，你需要能够回到最近访问的节点并探索它的其他路径，所以使用后进先出的栈是合适的。对于BFS，你需要按照你访问它们的顺序访问节点，所以使用先进先出的队列是合适的。，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。, 以数组的形式返回每一层节点的平均值。
第六章 二叉树part01
qq_16674623的博客
04-16 83
二叉树的递归遍历 二叉树的递归遍历 二叉树的统一迭代法
代码随想录 day14 第六章 二叉树part01
weixin_60315213的博客
03-08 856
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这是统一迭代法的写法， 如果学有余力，可以掌握一下。图片示例【来自代码随想录官网】图片示例【来自代码随想录官网】图片示例【来自代码随想录官网】图片示例【来自代码随想录官网】144.二叉树的前序遍历。145.二叉树的后序遍历。144.二叉树的前序遍历。145.二叉树的后序遍历。迭代法：【非递归遍历】
day13第6章 二叉树part01
m0_72126063的博客
11-09 88
跳过了迭代 ● 理论基础 ● 递归遍历
代码随想录 day11:第六章 二叉树part01
最新发布
z25735的博客
06-20 563
递归遍历（必须掌握） 递归三要素： 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
第六章 二叉树 part06
qq_16674623的博客
04-22 172
【代码】第六章 二叉树 part06。
第六章 二叉树part04
qq_16674623的博客
04-19 133
【代码】第六章 二叉树part04。
数据结构课件part2rar
10-13
"第6章 树.ppt" 和 "第6章 树和二叉树.ppt" 详细介绍了树的概念，包括树的定义、术语（如节点、根、子节点、父节点、叶节点、度）以及基本操作（如插入、删除）。特别地，二叉树是树的一个特例，每个节点最多只有两...
数据结构课件part3
10-13
5. **第六章 数和二叉树.ppt** - 二叉树是数据结构中的重要章节，会介绍二叉搜索树、完全二叉树、满二叉树以及二叉树的各种操作，如遍历和查找算法。 6. **第七章 图.ppt** - 图数据结构的深度学习，可能涵盖图的...
C语言通用范例开发金典.part2.rar
08-31
第1章 数据结构. 1 1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数：fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 1.1.3 一维数组的高级应用 5 范例1-3 一维数组...
C语言通用范例开发金典.part1.rar
08-31
第1章 数据结构. 1 1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数：fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 1.1.3 一维数组的高级应用 5 范例1-3 一维数组...
数据结构课件part4
10-13
第六章可能涵盖了链表的基本操作，如插入、删除、遍历以及链表的应用，比如实现LRU缓存策略。 2. **chap7.ppt - 树结构** 树是一种非线性的数据结构，模拟了自然界中的层级关系。常见的树有二叉树、二叉搜索树、...
突破程序员基本功的16课.part2
06-11
第6课　流程控制的陷阱 6.1　switch语句陷阱 6.1.1　default分支永远会执行吗 6.1.2　break的重要性 6.1.3　switch表达式的类型 6.2　标签引起的陷阱 6.3　if语句的陷阱 6.3.1　else隐含的条件 6.3.2　小心空语句 ...
卡内基梅隆网站+SSD5+数据结构 所有答案Part1（共三部分）.rar
07-05
Part1（共三部分）表明这是一个系列内容的第一部分，涵盖了多个练习题或考试（exam和exe文件）。这些文件名（如exam3、exe4等）很可能代表不同的作业、测试或模拟试题，每个文件包含了针对数据结构的不同问题和解决...
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值