【算法与数据结构】144、94、145、LeetCode二叉树的前中后遍历（递归法、迭代法）

已于 2024-02-04 13:09:25 修改
阅读量703 收藏
点赞数 3
分类专栏： 算法 文章标签： 算法
于 2023-07-15 11:20:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45765437/article/details/131736711
版权

文章目录

所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。

一、题目

在这里插入图片描述
在这里插入图片描述

二、递归算法

  思路分析：这道题比较简单，不多说了，大家直接看代码就行。注意前中后遍历是指中间节点的遍历顺序。同时中序和后序的代码也很类似，这里给出三道题代码。前中后递归遍历算法对比下来，仅仅改变了一两行代码，就改变了结点的遍历顺序。
  前序遍历程序如下：

class Solution {
public:
    // 前序遍历
    void traversal_preOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);                // 中
        traversal_preOrder(cur->left, vec);     // 左
        traversal_preOrder(cur->right, vec);    // 右
    }

    vector<int> preorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        vector<int> result;
        traversal_preOrder(root, result);
        return result;
    }
};

复杂度分析可以参考这篇文章二叉树多种遍历的时间复杂度和空间复杂度。

  • 时间复杂度： O ( n ) O(n) O(n)。
  • 空间复杂度： O ( n ) O(n) O(n)。

  中序遍历程序如下：

// 中序遍历
class Solution2 {
public:  
    void traversal_midOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal_midOrder(cur->left, vec);     // 左
        vec.push_back(cur->val);                // 中
        traversal_midOrder(cur->right, vec);    // 右
    }

    vector<int> inorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        vector<int> result;
        traversal_midOrder(root, result);
        return result;
    }
};

  后序遍历程序如下：

// 后序遍历
class Solution3 {
public:
    void traversal_postOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal_postOrder(cur->left, vec);     // 左
        traversal_postOrder(cur->right, vec);    // 右
        vec.push_back(cur->val);                 // 中
    }

    vector<int> postorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        vector<int> result;
        traversal_postOrder(root, result);
        return result;
    }
};

三、迭代算法

3.1 迭代算法1

  遍历树节点的时候要注意是右节点先入栈，左节点后入栈，这样在出栈的时候就是左节点先出栈。
  前序遍历程序如下：

// 前序遍历迭代法 中左右
class Solution4 {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        stack<TreeNode*> st;
        vector<int> 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;
    }
};

  中序遍历是左中右，需要一层层找到最左边的节点，在遍历的过程当中依次将遍历元素压入栈，最左边元素就在栈顶，可以首先输出，就实现左中右顺序的遍历。
  中序遍历程序如下：

// 中序遍历迭代法 左中右
class Solution5 {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        stack<TreeNode*> st;
        vector<int> result;
        TreeNode* node = root;
        while (node != NULL || !st.empty()) {   // 栈非空或节点非空, 每次循环更新node
            if (node != NULL) {
                st.push(node);
                node = node->left;
            }
            else {
                node = st.top();
                st.pop();
                result.push_back(node->val);
                node = node->right;    // 右节点
            }    
        }
        return result;
    }
};

  后序遍历只需要将前序遍历翻转一下就能实现。
  后序遍历程序如下：

// 后序遍历迭代法 左右中
class Solution6 {
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;
    }
};

3.2 迭代算法2 ——统一风格写法

  在迭代算法1中，迭代法实现的先中后序，其实风格也不是那么统一，除了先序和后序，有关联，中序完全就是另一个风格了，一会用栈遍历，一会又用指针来遍历。因此这里我们选择用一种统一的风格来写前中后遍历的迭代算法。目的就是实现类似递归算法中改变一两行代码就能前中后遍历相互转换。
  迭代算法1中中序遍历使用栈实现，它无法解决访问节点和处理节点不一致的情况，也就是说中序遍历时。我们是先访问中节点，然后在访问右节点和左节点，但是处理时，是先处理左节点、然后才是中节点和右节点。为了解决这个问题，我们将要访问的节点放入栈中，把要处理的节点也放入栈中，同时做标记，表示已经入栈，但是还没有处理。代码如下，可以看出，前中后遍历都只改动了一两行代码。
  中序遍历程序如下：

// 中序遍历，统一代码风格迭代写法
class Solution7 {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        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();
                result.push_back(node->val);    // 加入到结果集
            }
        }
        return result;
    }
};

  前序遍历程序如下：

// 前序遍历，统一代码风格迭代写法
class Solution8 {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        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);  // 右
                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 Solution9 {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        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();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

四、完整代码

# include <iostream>
# include <vector>
# include <stack>
using namespace std;
// 树节点定义
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_preOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);                // 中
        traversal_preOrder(cur->left, vec);     // 左
        traversal_preOrder(cur->right, vec);    // 右
    }

    vector<int> preorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        vector<int> result;
        traversal_preOrder(root, result);
        return result;
    }
};
// 中序遍历递归法
class Solution2 {
public:  
    void traversal_midOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal_midOrder(cur->left, vec);     // 左
        vec.push_back(cur->val);                // 中
        traversal_midOrder(cur->right, vec);    // 右
    }

    vector<int> inorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        vector<int> result;
        traversal_midOrder(root, result);
        return result;
    }
};
// 后序遍历递归法
class Solution3 {
public:
    void traversal_postOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal_postOrder(cur->left, vec);     // 左
        traversal_postOrder(cur->right, vec);    // 右
        vec.push_back(cur->val);                // 中
    }

    vector<int> postorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        vector<int> result;
        traversal_postOrder(root, result);
        return result;
    }
};
// 前序遍历迭代法 中左右
class Solution4 {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        stack<TreeNode*> st;
        vector<int> 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;
    }
};
// 中序遍历迭代法 左中右
class Solution5 {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        if (root->left == NULL && root->right == NULL) return { root->val };
        stack<TreeNode*> st;
        vector<int> result;
        TreeNode* node = root;
        while (node != NULL || !st.empty()) {   // 栈非空或节点非空, 每次循环更新node
            if (node != NULL) {
                st.push(node);
                node = node->left;
            }
            else {
                node = st.top();
                st.pop();
                result.push_back(node->val);
                node = node->right;    // 右节点
            }    
        }
        return result;
    }
};
// 后序遍历迭代法 左右中
class Solution6 {
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;
    }
};
// 中序遍历，统一代码风格迭代写法
class Solution7 {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        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();
                result.push_back(node->val);    // 加入到结果集
            }
        }
        return result;
    }
};
// 前序遍历，统一代码风格迭代写法
class Solution8 {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        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);  // 右
                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 Solution9 {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        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();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

void my_print(vector <int>& v, string msg)
{
    cout << msg << endl;
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << "  ";
    }
    cout << endl;
}

int main() {
    // 构造树
    TreeNode* node3 = new TreeNode(3);
    TreeNode* node2 = new TreeNode(2, node3, NULL);
    TreeNode* root = new TreeNode(1, NULL, node2);
    Solution7 s1;
    vector<int> result = s1.inorderTraversal(root);
    my_print(result, "中序遍历结果：");
	system("pause");
	return 0;
}

end

晚安66
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
在LeetCode的第94题中，目标是实现一个函数来返回给定二叉树的中序遍历结果。这个题目考察的是对二叉树遍历的理解以及如何用编程语言（这里可能是Python）来实现这个操作。 首先，我们来看第一种解题方法，即递归...
java-leetcode题解之第94题二叉树的中序遍历.zip
06-18
通过"java-leetcode题解之第94题二叉树的中序遍历.zip"这个资源，你可以学习到如何在Java中实现二叉树的中序遍历，这对于提高你的数据结构和算法能力非常有帮助。同时，这也会让你更好地理解递归和栈这两种重要的...
leetcode 94 二叉树的中序遍历 递归和迭代
shichap的博客
10-04 74
给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 迭代 class Solution { public List<Integer> inorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<>(); Stack<TreeNode
【LeetCode】二叉树的前序遍历（递归，迭代，Morris 遍历）
m0_57248981的博客
03-25 495
Morris 遍历使用二叉树节点中大量指向 null 的指针，将当前根节点的最右侧节点的right指向当前根节点，省去了栈的维护，连接之后可以直接顺着节点遍历完整个二叉树，以下图为例：
代码随想录算法训练Day14|LeetCode144-二叉树的前序遍历、LeetCode145二叉树的后序遍历、LeetCode94二叉树的中序遍历（递归、迭代、统一迭代法）
wish的博客
05-26 1007
刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。int val;大家会发现二叉树的定义和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。这里要提醒大家要注意二叉树节点定义的书写方式。在现场面试的时候 面试官可能要求手写代码，所以数据结构的定义以及简单逻辑的代码一定要锻炼白纸写出来。
二叉树的前中后序遍历（递归法、迭代法）leetcode144、94/145
欢迎来到我的博客~
07-02 619
给你二叉树的根节点 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]提示：树中节点数目在范围 [0, 100] 内。
LeetCode 刷题 [C++] 第145题. 二叉树的后序遍历 （递归与迭代）
心之所向、力之所及
12-02 266
分别使用递归和迭代方法实现二叉树的后序遍历
LeetCode 144 145 94 二叉树的三种遍历 -- 迭代法
今天你学习了吗？
01-30 161
参考文章1 参考文章2 思路： 之前我们学习了使用递归法来进行二叉树的三种遍历，这次我们考虑使用迭代法来进行遍历，使用栈来实现。推荐将两篇参考文章都看一遍。在两篇参考文章中，第一篇讲了如何使用迭代法来遍历，但是三种遍历方式的实现并不是特别统一，没法像递归法一样仅修改中间元素的访问时机来非常简单地从一种遍历顺序改造为另一种遍历顺序，而是需要较大幅度修改代码。第二篇则讲了如何将这种迭代法改造为可以统一实现的方式。 本篇文章中所附代码使用的是第二篇参考文章中提及的统一实现的方式。 注意点： 1、推入栈的顺序需要注
算法训练营第十四天 | LeetCode 144 二叉树的前序遍历、LeetCode 94 中序遍历、LeetCode 145 后序遍历（二叉树递归遍历、迭代遍历、统一迭代遍历（略））
qq_63149342的博客
04-30 247
此时若节点已经到达了最左下，取出最顶层节点（由于此时root指向的已经是null了所以需要赋值），将其值fangru记录结果的res向量中，将该节点pop，并把root赋值为它自身的右节点，这里不判断右节点是否存在是因为不存在下一次循环也可以直接赋为栈顶元素。中序遍历意思是从一个节点的左子节点开始，到它本身，再遍历它的右子节点结束，但这个过程一般要从遍历到最左下角的元素才开始记录，之后一路往上，记录到最右边结束。前序遍历意思是先从该节点本身开始遍历，之后遍历它的左子节点，再到它的右子节点结束。
【Leetcode】144.二叉树的前中后序遍历 递归法 迭代法
森森猪的博客
08-30 117
这道题掌握了基本概念后，代码很简单，但是一般大厂面试标明了只接受非递归法 迭代法解释 三种解法C++ 迭代法 首先分享一个图示法快速写出三种遍历的方法 任何算法的递归版本都可以改成非递归版本，因为函数递归调用其实质就是压栈的过程，那么我们完全可以使用堆栈来模拟这个过程。二叉树的遍历（递归法）很容易实现，本质是采用了栈帧的实现方式，函数调用就是压栈，函数求解就是出栈的过程，那么我们完全可以手动创建栈来模拟这个过程，按照指定遍历顺序迭代的访问二叉树的所有结点。 因为前序、中序、后序三种遍历方式在当前函数体内
leetcode94. 二叉树的中序遍历，递归法+迭代法。附带前序遍历方法
qq_51350957的博客
07-17 328
leetcode94. 二叉树的中序遍历，递归法+迭代法。附带前序遍历方法
LeetCode Java Algorithm 记录数据结构与算法训练题，分享java面试题.zip
06-16
在本压缩包“LeetCode Java Algorithm 记录数据结构与算法训练题，分享java面试题.zip”中，我们可以发现这是一份集成了Java编程语言、数据结构和算法的学习资源，特别针对LeetCode上的问题和Java面试题进行了整理。...
java-leetcode题解之第103题二叉树的锯齿形层序遍历.zip
06-18
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第103题——“二叉树的锯齿形层序遍历”。这道题目主要涉及数据结构中的二叉树以及算法中的层次遍历。下面将详细介绍相关知识点。 **二叉树**： 二叉树是...
leetcode走楼梯-Algorithms:数据结构和算法
07-01
leetcode走楼梯 Algorithms 基础算法实现 一、 排序算法 二、Leetcode 数组和链表 逻辑简单，注重实现 002 024 025 解决方法：尾插法 141 解决方法：集合，即哈希表；快慢指针 142 206 解决方法：迭代：双指针；递归...
【18】输出字符菱形
2301_78786609的博客
07-19 374
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 251
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 316
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 239
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
LeetCode 刻意练习：数据结构与算法精华
"这是一本关于数据结构与算法的练习册，主要基于LeetCode平台，涵盖了字符串、树、链表、数组、贪心算法等主题，共有30道精选题目，适合于学习数据结构与算法或者准备计算机相关研究生考试的人群。" 在本练习册中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晚安66

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值