第六章 二叉树part01-上

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

递归遍历

题目描述

给你二叉树的根节点 root，分别返回它节点的 前序 中序 后序 遍历。

解题思路

总体思路

通过递归版本进行二叉树的节点遍历，需要关注以下三个部分：

  1. 确定函数的返回值和参数列表
  2. 确定递归的终止条件
  3. 确定单层递归的逻辑

二叉树的三种遍历方式实际上对应着遍历中点的顺序，例如：

  • 前序遍历：中、左、右
  • 中序遍历：左、中、右
  • 后序遍历：左、右、中

这里以前序遍历为例，介绍一下前序遍历的递归遍历流程：

  1. 通过分析题意可以发现最终我们返回的是一个vector数组，因此在递归函数定义时，我们需要一个vector类型的参数用于保存递归调用过程中的节点值，还需要一个Treenode参数用于递归调用每个节点，由于结果是保存在vector中，因此无需返回值。
  2. 递归调用的终止条件为当前元素为空节点时，说明此时的调用的是叶子节点的左右子树，直接终止即可
  3. 由于是先序遍历，因此递归的逻辑自然是从中心节点开始，然后依次调用左右子树。

时空分析

  • 时间复杂度：O(N)
  • 空间复杂度：O(N)

代码实现

测试地址

先序：https://leetcode.cn/problems/binary-tree-preorder-traversal/description/

class Solution {
public:
    void travelVal(TreeNode* cur, vector<int>& vec) {
        // 递归终止条件
        if (cur == nullptr) {
            return;
        }
        vec.push_back(cur->val);    // 中
        travelVal(cur->left, vec);  // 左
        travelVal(cur->right, vec); // 右
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        travelVal(root, result);
        return result;
    }
};

中序：https://leetcode.cn/problems/binary-tree-inorder-traversal/description/

class Solution {
public:
    void travelVal(TreeNode* cur, vector<int>& vec) {
        // 递归终止条件
        if (cur == nullptr) {
            return;
        }
        travelVal(cur->left, vec);  // 左
        vec.push_back(cur->val);    // 中
        travelVal(cur->right, vec); // 右
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        travelVal(root, result);
        return result;
    }
};

后序：https://leetcode.cn/problems/binary-tree-postorder-traversal/description/

class Solution {
public:
    void travelVal(TreeNode* cur, vector<int>& vec) {
        // 递归终止条件
        if (cur == nullptr) {
            return;
        }
        travelVal(cur->left, vec);  // 左
        travelVal(cur->right, vec); // 右
        vec.push_back(cur->val);    // 中
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        travelVal(root, result);
        return result;
    }
};

迭代遍历

题目描述

给你二叉树的根节点 root，分别返回它节点的 前序 中序 后序 遍历。

解题思路

前序遍历

思路

先序遍历的顺序为：中-左-右，因此在遍历完当前节后后，我们实际上需要先将当前节点的右子节点压入栈中，然后再压入左子节点，确保左子节点的优先级更高，更先弹出，具体流程如下：

  1. 定义一个栈，将根节点压入栈中。

  2. 当栈不为空时，执行以下步骤：

    • 弹出栈顶节点，并输出其值。
    • 如果当前节点有右子节点，将其压入栈中。
    • 如果当前节点有左子节点，将其压入栈中。

  3. 重复步骤2，直到栈为空。

中序遍历

思路

中序遍历的顺序为：左-中-右，因此需要先处理所有的左子节点，将它们依次压入栈中，直至遇到空节点后，此时已发现最左子节点，弹出当前左子节点的值，然后继续处理当前左子节点的右子节点，具体流程如下：

  1. 初始化一个栈。

  2. 当栈不为空或当前节点不为空时，执行以下步骤：

    • 如果当前节点不为空，将其压入栈中，并移动到其左子节点。
    • 如果当前节点为空，说明已经到达最左下角，弹出栈顶节点并输出其值，然后移动到其右子节点。

  3. 重复步骤2，直到栈为空且当前节点也为空。

后序遍历

方式一

思路

后序遍历的顺序为：左-右-中，从前面可以得知先序遍历的顺序为：中-左-右，我们将先序遍历经过调整左右循序可以得到：中-右-左，再进行整体翻转后得到的最后的顺序结果：左-右-中，和后序遍历的顺序一致，因此代码只需要在先序遍历的基础上进行修改即可，具体流程如下：

  1. 定义一个栈用于临时存储节点
  2. 将根节点压入栈中
  3. 按照根-右-左的顺序依次操作节点，将值加入结果集中
  4. 反转结果集输出即可
方式二

思路

方式二和方式一的大体思路一致，都是对前序遍历（中-左-右）的变体，通过调整遍历顺序和使用栈来翻转最终的输出顺序，方式二使用了两个栈，第一个栈用来模拟递归的过程，第二个栈用来收集节点，并在最后通过第二个栈来输出结果，具体流程如下：

  1. 定义两个栈。

  2. 将根节点压入第一个栈中。

  3. 当第一个栈不为空时，执行以下步骤：

    • 弹出第一个栈的栈顶节点，并将其压入第二个栈中。
    • 如果当前节点有左子节点，将其压入第一个栈中。
    • 如果当前节点有右子节点，将其压入第一个栈中。

  4. 当第一个栈为空时，从第二个栈中依次弹出节点并输出其值。

方式三

思路

方式三使用一个栈来追踪未处理的节点，并通过一个循环结构，结合辅助变量来标记前一个访问的节点，从而实现了对二叉树的后序遍历，即先访问左子树，再访问右子树，最后访问根节点，并在遍历过程中，确保每个节点只在其左右子节点都已被处理后才被加入到遍历结果中，具体流程如下：

  1. 定义一个栈，将根节点压入栈中。
  2. 初始化一个指针lastPrinted用于记录上一次输出的节点。
  3. 从根节点开始，尽可能地向左深入，并将途径的每个节点都压入栈中。
  4. 无法继续向左时，从栈中取出节点。如该节点右子树为空或已处理，则将其值添加到结果向量中，并标记此节点为已处理。否则，将此节点重新压回栈中，并转向处理其右子树。
  5. 重复以上步骤，直到所有节点都被处理。

代码实现

前序遍历实现

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

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* head) {
        // 定义vector数组，用于存储遍历后的节点值
        vector<int> result;
        // 如果当前二叉树不是空树，开始遍历
        if (head != nullptr) {
            // 定义一个栈存放将要访问的节点
            stack<TreeNode*> stack;
            // 将根节点压入栈中
            stack.push(head);
            // 当栈不为空时处理节点
            while (!stack.empty()) {
                // 取出栈顶元素
                head = stack.top();
                // 弹出栈顶元素
                stack.pop();
                // 将节点值添加到结果列表中
                result.push_back(head->val);
                // 如果存在右子节点，将右子节点压入栈中（由于栈的LIFO特性，先压右子节点）
                if (head->right)
                    stack.push(head->right);
                // 如果存在左子节点，将左子节点压入栈中
                if (head->left)
                    stack.push(head->left);
            }
        }
        // 返回遍历结果
        return result;
    }
};

中序遍历实现

测试：https://leetcode.cn/problems/binary-tree-inorder-traversal/

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* head) {
        // 结果数组，用来存储中序遍历的结果
        vector<int> result;
        // 如果头节点不为空，开始遍历
        if (head != nullptr) {
            // 使用栈来管理遍历过程中的节点
            stack<TreeNode*> stack;
            // 当当前节点不为空或栈不为空时，继续处理
            while (head != nullptr || !stack.empty()) {
                // 如果当前节点不为空，将其压入栈中，并前往左子节点
                if (head != nullptr) {
                    stack.push(head);
                    head = head->left;
                } else {
                    // 如果当前节点为空，说明左侧已经处理完毕，处理栈顶节点
                    head = stack.top();
                    stack.pop();
                    // 将栈顶节点值添加到结果数组中
                    result.push_back(head->val);
                    // 移动到右子节点
                    head = head->right;
                }
            }
        }
        // 返回中序遍历的结果
        return result;
    }
};

后序遍历实现

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

方式一
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        // 创建一个用于存储后序遍历结果的向量
        vector<int> result;
      
        // 创建一个栈，用于临时存储节点
        stack<TreeNode*> st;
      
        // 如果根节点为空，则返回空的结果向量
        if (root == nullptr)
            return result;
      
        // 将根节点推入栈中
        st.push(root);
      
        // 当栈不为空时，循环继续
        while (!st.empty()) {
            // 取栈顶元素即当前节点
            root = st.top();
            // 弹出栈顶元素
            st.pop();
            // 将当前节点的值加入到结果向量中
            result.push_back(root->val);
          
            // 如果当前节点有左子节点，则将左子节点推入栈中
            if (root->left)
                st.push(root->left);
            // 如果当前节点有右子节点，则将右子节点推入栈中
            if (root->right)
                st.push(root->right);
        }
        // 反转结果向量，因为我们是以根-右-左的顺序加入结果的，后序遍历应为左-右-根
        reverse(result.begin(), result.end());
      
        // 返回后序遍历的结果
        return result;
    }
};
方式二
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* head) {
        // 创建一个用于存储后序遍历结果的向量
        vector<int> ans;

        // 检查根节点是否为空
        if (head != nullptr) {
            // 创建一个栈，用于临时存储节点
            stack<TreeNode*> stack;
            // 创建一个栈，用于收集节点值
            stack<TreeNode*> collect;
          
            // 将根节点推入栈中
            stack.push(head);
          
            // 当栈不为空时，循环继续
            while (!stack.empty()) {
                // 取栈顶元素作为当前节点
                head = stack.top();
                // 弹出栈顶元素
                stack.pop();
              
                // 将当前节点推入收集栈中
                collect.push(head);
              
                // 如果当前节点有左子节点，则将左子节点推入栈中
                if (head->left != nullptr) {
                    stack.push(head->left);
                }
                // 如果当前节点有右子节点，则将右子节点推入栈中
                if (head->right != nullptr) {
                    stack.push(head->right);
                }
            }
            // 收集栈中的元素（即节点值），并添加到最终结果向量中
            while (!collect.empty()) {
                ans.push_back(collect.top()->val);
                collect.pop();
            }
        }
        // 返回后序遍历的结果
        return ans;
    }
};
方式三
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        // 创建一个向量来存储后序遍历的结果
        vector<int> ans;

        // 如果根节点为空，则直接返回空的向量
        if (root == nullptr) return ans;

        // 创建一个栈来辅助后序遍历
        stack<TreeNode*> stack;
        // 定义一个指针prev，用于记录上一个访问的节点
        TreeNode* prev = nullptr;
        // 当根节点不为空或栈不为空时，循环继续
        while (root != nullptr || !stack.empty()) {
            // 遍历到最左边的节点
            while (root != nullptr) {
                stack.push(root); // 将当前节点压入栈中
                root = root->left; // 移动到左子节点
            }
            // 回溯到最近的未处理节点
            root = stack.top(); // 获取栈顶元素，即当前需处理的节点
            stack.pop(); // 弹出栈顶元素

            // 如果当前节点的右子节点为空，或者右子节点已经被访问
            // 则可以处理当前节点
            if (root->right == nullptr || root->right == prev) {
                ans.push_back(root->val); // 将当前节点的值添加到结果向量中
                prev = root; // 更新prev为当前节点
                root = nullptr; // 重置root为nullptr，准备下一次循环
            } else {
                // 如果当前节点的右子节点还没被访问，则
                // 将当前节点再次压入栈中，并移动到右子节点
                stack.push(root);
                root = root->right;
            }
        }
        // 返回后序遍历的结果
        return ans;
    }
};

统一迭代

思路

这里以中序遍历为例进行说明：

在使用栈进行二叉树的中序遍历时，通常会遇到访问节点（遍历节点）和处理节点（将元素放进结果集）的时机不一致的问题。这是因为中序遍历的顺序是“左-根-右”，在遍历过程中，我们需要先访问（即移动到）最左边的节点，然后才能开始处理节点。

如果我们只使用栈来访问节点，而不使用额外的标记或机制，我们无法知道何时应该开始处理节点。例如，当我们到达最左边的节点时，我们可能已经将许多节点压入了栈中，但我们无法确定何时应该开始从栈中弹出节点并处理它们。

为了解决这个问题，我们可以使用使用NULL标记 在每个节点前压入一个NULL标记到栈中。当栈顶元素为NULL时，我们知道下一个节点是一个待处理的节点。这种方法允许我们在正确的时机处理节点，即在访问了所有左子节点之后。

代码实现

中序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        // 创建一个向量来存储中序遍历的结果
        vector<int> result;

        // 创建一个栈来辅助中序遍历
        stack<TreeNode*> st;

        // 如果根节点不为空，将其压入栈中
        if (root != nullptr)
            st.push(root);

        // 当栈不为空时，循环继续
        while (!st.empty()) {
            // 获取栈顶元素作为当前节点
            TreeNode* node = st.top();

            // 如果当前节点不为空
            if (node != NULL) {
                // 弹出栈顶元素
                st.pop();

                // 如果当前节点有右子节点，将其压入栈中
                if (node->right) //右
                    st.push(node->right);

                // 将当前节点再次压入栈中，并在其前压入一个NULL标记
                st.push(node); //中
                st.push(NULL);

                // 如果当前节点有左子节点，将其压入栈中
                if (node->left) //左
                    st.push(node->left);
            } else {
                // 如果栈顶元素为NULL，说明当前节点应该被处理
                // 弹出NULL标记
                st.pop();

                // 弹出当前节点
                node = st.top();
                st.pop();

                // 将当前节点的值添加到结果向量中
                result.push_back(node->val);
            }
        }
        // 返回中序遍历的结果
        return result;
    }
};

前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != nullptr)
            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();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != nullptr)
            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();
                result.push_back(node->val);
            }
        }
        return result;
    }
}
C1aySec
关注
  • 35
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
coursera-algorithms-part-1
06-27
在"Coursera-algorithms-part-1-master"这个压缩包中，你将找到课程相关的代码示例、练习题和解决方案，它们将帮助你亲手实践这些算法，加深理解和记忆。动手实践是学习算法的关键，通过编写和调试代码，你可以更...
Algorithms-Part-I:Coursera课程
07-20
《算法-第一部分》是Coursera平台上的一个知名在线课程，主要针对计算机科学和信息技术领域的初学者，也适合希望巩固基础的进阶者。这个课程深入浅出地讲解了算法设计与分析的基础知识，是理解和掌握计算问题解决的...
第六章 二叉树part01-下
a781333978的博客
06-19 1157
使用一个队列来按顺序访问二叉树的每个节点，同时用一个哈希表来记录每个节点的层级。遍历时，如果碰到一个新层级的节点，就在结果列表中加一个新的子列表。这样，就能一层层地把节点值收集起来，实现了二叉树的逐层遍历。简单来说，就像在排队接水，每个人（节点）按顺序来，按层级分组，确保每一层的人都能按顺序接到水。public:// 结果向量，用于存储每一层的节点值if(root!= nullptr){ // 如果根节点不为空// 创建一个队列，用于BFS遍历// 创建一个哈希表，用于记录每个节点的层级。
Day14 第六章 二叉树part01-二叉树（递归遍历，迭代遍历，统一迭代）
weixin_65279006的博客
09-06 129
第一次经过一个节点时，不能直接弹出它本身，因为中序遍历要先弹出它的左节点，这时候就应该先弹出然后在压入右节点之后再将其本身再次压入，然后压入左节点，第二次经过的时候再彻底弹出。写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。4.总体思路是，首先押入根节点，然后弹出一个节点就押入它的右左节点，这样每次先弹出自己，然后弹出左，左节点弹出完了，栈不为空然后依次弹出右节点。
Day16-第六章 二叉树 part02-层序遍历，反转二叉树，对称二叉树
weixin_65279006的博客
09-07 85
1.与前中后序遍历不同的是，因为层序遍历要把一层的节点全给处理掉再进行下一层，所以需要两个循环来保证一层的节点都被处理了。简单地说，不同的遍历方法对应着不同的遍历需求，而每种数据结构（队列和栈）提供了满足这些需求的特定功能。对于DFS，你需要能够回到最近访问的节点并探索它的其他路径，所以使用后进先出的栈是合适的。对于BFS，你需要按照你访问它们的顺序访问节点，所以使用先进先出的队列是合适的。，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。, 以数组的形式返回每一层节点的平均值。
第六章 二叉树part01
qq_16674623的博客
04-16 91
二叉树的递归遍历 二叉树的递归遍历 二叉树的统一迭代法
代码随想录 day14 第六章 二叉树part01
weixin_60315213的博客
03-08 867
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这是统一迭代法的写法， 如果学有余力，可以掌握一下。图片示例【来自代码随想录官网】图片示例【来自代码随想录官网】图片示例【来自代码随想录官网】图片示例【来自代码随想录官网】144.二叉树的前序遍历。145.二叉树的后序遍历。144.二叉树的前序遍历。145.二叉树的后序遍历。迭代法：【非递归遍历】
day13第6章 二叉树part01
m0_72126063的博客
11-09 95
跳过了迭代 ● 理论基础 ● 递归遍历
代码随想录 day11:第六章 二叉树part01
z25735的博客
06-20 585
递归遍历（必须掌握） 递归三要素： 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
第六章 二叉树 part06
qq_16674623的博客
04-22 185
【代码】第六章 二叉树 part06。
第六章 二叉树part04
qq_16674623的博客
04-19 143
【代码】第六章 二叉树part04。
Road vehicles - Unified diagnostic services (UDS) -Part 1:Appl
06-07
《道路车辆 - 统一诊断服务 (UDS) - 第1部分：应用层》是国际标准化组织（ISO）制定的一项标准，旨在规范汽车电子控制单元（ECU）的诊断服务，确保诊断测试器（客户端）能够对车载电子系统如电子燃油喷射、自动变速...
算法导论(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 ...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 443
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 210
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 226
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
摩尔投票算法
qq_55846232的博客
07-14 470
摩尔投票算法的介绍以及相关例题的讲解

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值