代码随想录算法训练营第十四天 | 二叉树前中后序的递归遍历与迭代遍历

Yirschen

已于 2024-01-13 16:29:57 修改

阅读量100

点赞数

文章标签： leetcode

于 2023-04-18 00:51:31 首次发布

本文链接：https://blog.csdn.net/Yirschen/article/details/130212262

版权

理论基础

文章讲解：代码随想录 (programmercarl.com)

视频讲解：关于二叉树，你该了解这些！| 二叉树理论基础一网打尽，二叉树的种类、二叉树的存储方式、二叉树节点定义、二叉树的遍历顺序_哔哩哔哩_bilibili

二叉树的定义

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

递归遍历

文章讲解：代码随想录 (programmercarl.com)

视频讲解：每次写递归都要靠直觉？这次带你学透二叉树的递归遍历！| LeetCode：144.前序遍历，145.后序遍历，94.中序遍历_哔哩哔哩_bilibili

递归三要素

每次写递归，都按照这三要素来写，可以保证大家写出正确的递归算法！

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

前序遍历

利用递归三要素来实现前序遍历

确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：
```
void traversal(TreeNode* cur, vector<int>& vec)
```
确定终止条件：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：
```
if (cur == NULL) return;
```
确定单层递归的逻辑：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：
```
vec.push_back(cur->val);    // 中
traversal(cur->left, vec);  // 左
traversal(cur->right, vec); // 右
```

完整版的前序遍历如下，

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& 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;
    }
};

例题：LeetCode144

中序遍历

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    vec.push_back(cur->val);    // 中
    traversal(cur->right, vec); // 右
}

例题：LeetCode94

后序遍历

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    traversal(cur->right, vec); // 右
    vec.push_back(cur->val);    // 中
}

例题：LeetCode145

迭代遍历

文档讲解：代码随想录 (programmercarl.com)

视频讲解：写出二叉树的非递归遍历很难么？这次让你不再害怕非递归！|二叉树的非递归遍历 | 二叉树的遍历迭代法 | 前序与中序_哔哩哔哩_bilibili

写出二叉树的非递归遍历很难么？这次再带你写出中序遍历的迭代法！|二叉树的非递归遍历 | 二叉树的遍历迭代法_哔哩哔哩_bilibili

前序遍历

！！！思路

前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，

遍历栈，

弹出栈顶，即中间节点，进行相应处理；

若该中间节点的右孩子不为空，将其入栈；

若该中间节点的左孩子不为空，将其入栈；

注意1：为什么要先加入右孩子，再加入左孩子呢？因为这样出栈的时候才是中左右的顺序。

注意2：代码中空节点不入栈。

代码

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;
    }
};

模拟过程
在这里插入图片描述

后序遍历

先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下前序迭代遍历中左右孩子的入栈顺序，就变成中右左的遍历顺序，然后再对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;
    }
};

中序遍历（难）

对于前序遍历和后序遍历的迭代过程中，有两个操作：

处理：将元素放进result数组中
访问：遍历节点

为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢？因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理(放进result数组)的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。

那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

那么在使用迭代法写中序遍历，就需要借用指针的遍历来访问节点，栈则用来处理节点上的元素(放进result数组)。

！！思路

若指针不为空，让所指结点入栈，让指针一直往左子树走，沿途遍历过的节点都入栈，直到NULL；
若指针为空，则从栈中弹出元素，就是要处理的元素(放入result数组)，同时指针指向该节点，然后让指针到右孩子，继续上一步边入栈边往左走。

！！伪代码

指针指向根节点；

当指针不为空或栈不为空时，

若指针不为空，将当前节点入栈，指针指向左孩子(左)；

若指针为空，从栈中弹出数据(中)放进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;
    }
};

总结

可以看出前序和中序是完全两种代码风格，并不像递归写法那样代码稍做调整，就可以实现前后中序。

这是因为前、后序遍历中访问节点（遍历节点）和处理节点（将元素放进result数组中）可以同步处理，但是中序就无法做到同步！

那么问题又来了，难道二叉树前后中序遍历的迭代法实现，就不能风格统一么（即前序遍历改变代码顺序就可以实现中序和后序）？

当然可以，这种写法还不是很好理解，不想学这种方法，避免混乱；需要的话，可以参照代码随想录 (programmercarl.com)。

Yirschen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第十四天 | 二叉树前中后序的递归遍历与迭代遍历

可以看出前序和中序是完全两种代码风格，并不像递归写法那样代码稍做调整，就可以实现前后中序。这是因为前、后序遍历中访问节点（遍历节点）和处理节点（将元素放进result数组中）可以同步处理，但是中序就无法做到同步！那么问题又来了，难道二叉树前后中序遍历的迭代法实现，就不能风格统一么（即前序遍历改变代码顺序就可以实现中序和后序）？当然可以，这种写法还不是很好理解，不想学这种方法，避免混乱；需要的话，可以参照代码随想录 (programmercarl.com)。
复制链接

扫一扫