【力扣】二叉树的遍历

力扣中最为经典的二叉树前中后序遍历：

144. 二叉树的前序遍历 - 力扣（LeetCode）

94. 二叉树的中序遍历 - 力扣（LeetCode）

145. 二叉树的后序遍历 - 力扣（LeetCode）

迭代法：

迭代法显示维护栈，利用栈先入后出的原理调整遍历到的数据的顺序。

前序遍历：

遍历规律：“根左右”。创建一个栈，先放入节点，弹出栈顶，然后根据先右后左的规律放入两个子节点，再弹出栈顶，直到栈为空。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;//结果
        if(root == nullptr) return res;//判空

        stack<TreeNode*> stk;//栈
        //node作为一个标记，前序遍历的规律是根左右
        //node需要先赋值根节点，再利用根节点得到左右两个子节点
        TreeNode* node = root;//从根节点开始，向栈内压入根节点
        stk.push(root);

        while(!stk.empty()){//结束条件为空栈

            //将栈顶弹出的节点放入中介，并将val值压入res数组中
            node = stk.top();
            res.push_back(node->val);
            stk.pop();

            //根据先右后左的原则将节点压入栈中
            if(node->right) stk.push(node->right);
            if(node->left) stk.push(node->left);
        }
        return res;
    }
};

中序遍历：

遍历规律左根右，先将最左边的所有节点放入栈内，node作为遍历树的标记先移动到最左的叶子结点上，弹出栈顶；注意：此时node是叶子结点，是没有子节点的，node=node->right导致node为空节点，这时就会直接弹出栈顶节点，也就是该子节点的父节点，等到再次运行到node=node->right的时候，标记就会移动到右子节点，此时就完成了“左根右”。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) return res;

        stack<TreeNode*> stk;
        TreeNode* node = root;
        
        while(node || !stk.empty()){
            while(node){
                stk.push(node);
                node = node->left;
            }
            node = stk.top();
            res.push_back(node->val);
            stk.pop();
            node = node->right;
        }
        return res;
    }
};

后序遍历：

遍历规律：左右根。其实前中后是根节点相对与左右子节点来判断的，左右的顺序不会变。

后序遍历利用了两个栈，第一个栈用来找根节点的两个子节点，第二个栈用来调整两个子节点的顺序。那么：先将右子节点压入栈中，再压入左子结点，这样就不需要第二个栈来调整顺序了吗？其实这是不对的，因为无论是前中后哪种遍历，都是先遍历左子树，再遍历右子树。如果像上述这样调整就会先遍历右子树，从而导致结果不正确。

后序遍历，无论如何根节点都是最后一个，所以从根节点开始，先将根节点压入栈2中，再利用标记将左右两个子节点压入栈1；然后将栈1顶弹出并压入栈2，该节点的两个子节点压入栈1，以此类推，最后栈2按顺序依次弹出栈顶，这个顺序就是后序遍历的顺序。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) return res;

        stack<TreeNode*> stk1, stk2;
        stk1.push(root);
        
        while(!stk1.empty()){
           TreeNode* node = stk1.top();
           stk1.pop();
           stk2.push(node);
           if(node->left) stk1.push(node->left);
           if(node->right) stk1.push(node->right); 
        }
        while(!stk2.empty()){
            res.push_back(stk2.top()->val);
            stk2.pop();
        }
        return res;
    }
};

递归法

递归方法因人而异，有的觉得简单很好理解，不过大部分就算知道了原理也需要一些时间去消化。不过一旦理解的递归算法就会有一种豁然开朗的感觉。

递归算法的二叉树遍历其实十分简单，前中后序也只需要调整两三行代码即可。

class Solution {
public:
    vector<int> func(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) return res;

        vector<int> L, R; 
        if(root->left != nullptr) L = func(root->left);
        if(root->right != nullptr) R = func(root->right);

        //下面的三行根据不同遍历规则选择顺序即可
        for(auto it : L) res.push_back(it);
        for(auto it:R) res.push_back(it);
        res.push_back(root->val);
        return res;
    }
};

附带一个很清晰的解释：

二叉树遍历的递归实现详解（先序、中序、后序和层次遍历） - violet-evergarden - 博客园 (cnblogs.com)