数据结构-二叉树的遍历

已于 2023-04-03 15:58:16 修改
阅读量265 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 leetcode 算法 Powered by 金山文档
于 2023-04-03 15:47:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44177768/article/details/128692855
版权

代码随想录 (programmercarl.com) 学习

  1. 二叉树的递归遍历/迭代遍历

递归三要素

  1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

  1. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

  1. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]
// 递归方法
// 前序遍历 中 左 右
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {  // vec 数组
        if (cur == NULL) return;    // 终止条件 
        vec.push_back(cur->val);    // 中 
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

//迭代方法
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. 二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[3,2,1]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
//递归遍历
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
        vec.push_back(cur->val);    // 中
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

//迭代方法
class Solution {
public:
    vector<int> postorderTraversal(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->left) st.push(node->left); // 相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）
            if (node->right) st.push(node->right); // 空节点不入栈
        }
        reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
        return result;
    }
};

94. 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
//递归方法
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal(cur->left, vec);  // 左
        vec.push_back(cur->val);    // 中
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return 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;
    }
};

  1. 层序遍历

递归遍历 ------- 栈 深度优先

层序遍历 ------- 使用 队列 实现二叉树 广度优先遍历

102. 二叉树的层序遍历

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;              // 创建队列
        if (root != NULL) que.push(root); // 根节点不为空，将根节点加入队列
        vector<vector<int>> result;       //  结果二维数组
        while (!que.empty()) {            //  队列不为空就一直遍历
            int size = que.size();  // 队列大小
            vector<int> vec;   // 定义一维数组，放一层的数值
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {  
                TreeNode* node = que.front(); // node 获取队列第一个元素
                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;
    }
};

# 递归法
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;
        order(root, result, depth);
        return result;
    }
};

107. 二叉树的层序遍历 II

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]

把102 题的 result 数组反转一下

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            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);
        }
        reverse(result.begin(), result.end()); // 在这里反转一下数组即可
        return result;

    }
};

199. 二叉树的右视图

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

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
示例 2:
输入: [1,null,3]
输出: [1,3]
示例 3:
输入: []
输出: []

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        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); // 将每一层的最后元素放入result数组中
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<double> result;               // 结果一维数组
        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;            // sum改变记录总和
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(sum / size); // 每层总和/size  将每一层均值放进结果集
        }
        return result;
    }
};

429. N 叉树的层序遍历

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

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;                  // 定义队列
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        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]);
                }
            }
            result.push_back(vec);
        }
        return result;

    }
};

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]
示例2：
输入: root = [1,2,3]
输出: [1,3]
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result; 
        while (!que.empty()) {
            int size = que.size();
            int maxValue = INT_MIN;       
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();   // 出队列     取每一层的最大值
                maxValue = node->val > maxValue ? node->val : maxValue;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(maxValue); // 把最大值放进数组
        }
        return result;
    }
};

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

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

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

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

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

示例 1：

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
示例 2:
输入：root = []
输出：[]
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;                  // 定义队列
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front();   // 取出一层的头结点
                    que.pop();               // 出队列
                    node = nodePre;          // 
                } else {
                    node = que.front();      // 取每一层的其他节点 
                    que.pop();               // 出队列
                    nodePre->next = node;    // 本层前一个节点next指向本节点
                    nodePre = nodePre->next; // 
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

117. 填充每个节点的下一个右侧节点指针 II
给定一个二叉树：
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。
初始状态下，所有 next 指针都被设置为 NULL 。

示例 1：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。
示例 2：
输入：root = []
输出：[]
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            Node* nodePre;   // 前驱点
            Node* node;      //
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();          
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;
    }
};

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

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

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

3

/ \

9 20

/ \

15 7

返回它的最大深度 3 。

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++; // 记录深度
            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;
    }
};

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

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;
    }
};
I'mFAN
关注
专栏目录
数据结构-二叉树遍历
11-05
二叉树作为一种重要的数据结构，广泛应用于计算机科学的各个领域，如编译器设计、操作系统、数据库、图形学等。它的遍历是理解和操作二叉树的基础，这其中包括前序遍历、中序遍历、后序遍历以及层次遍历（也称为广度...
层序遍历二叉树并输出到二维数组中
冯宝宝
07-10 211
【代码】层序遍历二叉树并输出到二维数组中。
从二维数组看二叉树
a1309602336的博客
12-07 84
每次迭代都会增加一层j++；发现·描述二叉树形成过程如注释。每层都从i=1开始，
二叉树的顺序存储
study_way的博客
04-22 3813
二叉树的顺序存储结构是把二叉树的所有节点按照一定的次序顺序存储到一组包含n个存储单元的空间中。在二叉树的顺序存储结构中只存储节点的值，不存储节点之间的 逻辑关系，节点之间的逻辑关系由数组下标的顺序来体现。 二叉树的顺序存储原则是：不管给定的二叉树是不是完全二叉树，都看做完全二叉树。即按完全二叉树的层次次序把各个节点依次存入数组中。 如图所示二叉树存放在数组中就是{0,1,2,3,4,5,6,7,8...
二叉树的几种遍历方法
qq_60717298的博客
02-25 705
二叉树的遍历有四种： （1） 前序遍历（根左右） （2）中序遍历（根左右） （3） 后序遍历（根左右） （4） 层序遍历（一层一层来） 记住了，好那就来题吧 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 示例 1：输入：root = [1,null,2,3] 输出：[1,2,3] 示例 2：输入：root = [] 输出：[] 示例 3：输入：root = [1] 输出：[1] 法一：递归 解决二叉树的遍历问题应该想到的方法是递归，准备工作如下 .
二叉树-数据结构
weixin_60613303的博客
11-18 896
二叉树数据结构简单操作
数据结构-二叉树遍历(详细过程).docx
10-24
二叉树是一种基础的数据结构，它在计算机科学中扮演着重要的角色，特别是在算法设计和程序实现中。在二叉树中，每个节点最多有两个子节点，分别被称为左子节点和右子节点，这种特殊的结构使得二叉树的操作具有独特性...
二叉树遍历问题-二叉树遍历问题
11-12
二叉树遍历是计算机科学中的一个重要概念，主要应用于数据结构和算法领域。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树遍历是指按照特定顺序访问二叉树的所有...
数据结构-二叉树Java实现及其遍历算法
最新发布
09-24
数据结构-二叉树Java实现及其遍历算法，代码示例中实现了中序遍历，简单易学。
数据结构课程设计报告-二叉树的遍历.docx
03-07
数据结构课程设计报告-二叉树的遍历 本报告基于二叉树的遍历方法，旨在通过递归和非递归两种方法创建一棵二叉树，并对其进行先序遍历、中序遍历、后序遍历及层次遍历，并求出该二叉树的深度和叶子结点数。同时，...
数据结构-二叉树的广度优先遍历
08-23
以下是使用C语言编写的二叉树的广度优先遍历（也称为层次遍历）算法的示例代码： #include #include // 定义二叉树的节点结构 typedef struct Node { int data; struct Node* left; struct Node* right; } ...
数据结构_二叉树遍历_
09-29
二叉树作为一种重要的数据结构，其遍历算法是理解和应用二叉树的基础。本程序聚焦于二叉树的三种基本遍历方法：先序遍历、中序遍历和后序遍历。 **一、先序遍历** 先序遍历的顺序是：根节点 -> 左子树 -> 右子树。...
数据结构-中序遍历平衡二叉树
08-06
数据结构——中序遍历平衡二叉树
漫话数据结构-二叉树的存储和遍历.pptx
11-03
总之，理解二叉树的存储结构和遍历方法是掌握数据结构基础的重要环节，这对于编写高效的算法和解决复杂问题至关重要。在实际应用中，如编译器、搜索算法、文件系统等，二叉树都是不可或缺的数据结构。通过深入学习和...
数据结构--二叉树--思维导图.pdf
08-29
"数据结构--二叉树--思维导图" 二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的...
层次遍历二叉树
weixin_46314022的博客
11-17 1690
void HierarchyOrder(BiTreeNode* root) // 二叉树的层次遍历（队列实现） // 参数：二叉树根节点root // 输出：二叉树的层次遍历，中间没有空格，末尾不换行。 { // 请在这里补充代码，完成本关任务 /********** Begin *********/ queue<BiTreeNode*> q; if(root!=NULL) { q.push(root); } while(!
二叉树的前、中、后序遍历与层序遍历
m0_67683346的博客
07-12 8834
前、中、后序及层序遍历二叉树
二叉树的四种遍历算法（结构体数组）
m0_65129892的博客
01-06 1663
二叉树的遍历，使用结构体数组
二叉树及其应用
weixin_51188461的博客
06-07 1290
//二叉树注意递归的思想的应用 实现二叉树的创建–计算二叉树的深度和节点个数–递归实现二叉树左右子树交换–非递归实现二叉树左右子树交换–层次遍历二叉树 struct BiTreeNode { char data; // 树节点元素 BiTreeNode* left; // 左子树指针 BiTreeNode* right; // 右子树指针 }; 利用先序遍历创建二叉树，参数：先序遍历字符串s，字符串初始下标i=0，字符串长度le
数据结构-二叉树遍历课程设计报告:设计目的、具体内容与解决方法、结果分析。
本次课程设计的主题是二叉树的遍历，通过本设计旨在帮助学生加深对数据结构中二叉树的理解，提高解决相关问题的能力。设计的具体要求包括实现二叉树的先序、中序、后序以及层次遍历四种方式，并对这四种遍历方式进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值