代码随想录算法训练营第十三天|LeetCode144/145/94. 二叉树的前序/后序/中序遍历，LeetCode102. 二叉树的层序遍历-优快云博客

本文链接：https://blog.youkuaiyun.com/Liverpool0519/article/details/149917255

LeetCode144. 二叉树的前序遍历

题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）
文章讲解：代码随想录
视频讲解：每次写递归都要靠直觉？这次带你学透二叉树的递归遍历！| LeetCode：144.前序遍历，145.后序遍历，94.中序遍历_哔哩哔哩_bilibili

递归思路：比较简单，记得前序遍历是中左右即可。

递归代码：

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

非递归思路：定义一个栈，根据先序中左右的性质，先加入根节点，然后再加入右孩子，再加入左孩子（注意此处先加入右孩子！！是因为栈是先进后出）。

非递归代码：

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

LeetCode145. 二叉树的后序遍历

题目链接：145. 二叉树的后序遍历 - 力扣（LeetCode）
文章讲解：代码随想录
视频讲解：每次写递归都要靠直觉？这次带你学透二叉树的递归遍历！| LeetCode：144.前序遍历，145.后序遍历，94.中序遍历_哔哩哔哩_bilibili

递归思路：后序是左右中。

递归代码：

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> postorderTraversal(TreeNode* root) {
        vector<int>result;
        traversal(root,result);
        return result;
    }
};

非递归思路：和之前的先序遍历非常像，先序遍历输出是中左右，只需要先改变左右孩子的加入顺序，输出就可以变成中右左，最后在reverse一下result数组，输出就会变成左右中。

非递归代码：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*>st;
        vector<int>result;
        TreeNode* node;
        if(root==NULL){
            return result;
        }
        st.push(root);
        while(!st.empty()){
            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;
    }
};

LeetCode94. 二叉树的中序遍历

题目链接：94. 二叉树的中序遍历 - 力扣（LeetCode）
文章讲解：代码随想录
视频讲解：每次写递归都要靠直觉？这次带你学透二叉树的递归遍历！| LeetCode：144.前序遍历，145.后序遍历，94.中序遍历_哔哩哔哩_bilibili

递归思路：中序是左中右。

递归代码：

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> inorderTraversal(TreeNode* root) {
        vector<int>result;
        traversal(root,result);
        return result;
    }
};

非递归思路：和前两个不太一样，这个需要先遍历到最左侧，直到左孩子为空，开始pop，pop完了开始尝试处理右侧孩子。

非递归代码：

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(); 
                st.pop();
                result.push_back(cur->val);     
                cur=cur->right;               
            }
        }
        return result;
    }
};

以上三题的统一迭代法（非递归）

中序

思路：由于中序遍历的访问节点和处理节点不一致，所以没法直接用前序和后序的迭代法。为了统一三种遍历方式的迭代法，便提出了以下这种写法，在第一次遇到中间那个节点的时候，先弹出，再按右孩子，中，左孩子的顺序放入，请注意在放入中的时候后面需要跟个NULL，用于标记这个中间的结点已经遍历过了，在之后遇到NULL的时候，说明这个节点已经被遍历过了，因此此时要把这个节点加入到result中。

代码：

class Solution {
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 Solution {
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 Solution {
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;
    }
};

LeetCode102. 二叉树的层序遍历

题目链接：102. 二叉树的层序遍历 - 力扣（LeetCode）
文章讲解：代码随想录
视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

思路：层序遍历需要用到队列，我们需要先把每一层的节点加入到队列中，同时记录每一层的节点个数（队列的size），然后将每一层的节点弹出并加入结果中，弹出的同时队列加入他的左孩子和右孩子，之后按层循环往复。

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*>que;
        vector<vector<int>>result;
        if(root!=NULL){
            que.push(root);
        }
        while(!que.empty()){
            int size=que.size();
            vector<int>vec;
            while(size--){
                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);
        }
        return result;
    }
};