LeetCode 145. 二叉树的后序遍历c++/java详细题解

Posted 2021-09-23 林深时不见鹿

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode 145. 二叉树的后序遍历c++/java详细题解相关的知识，希望对你有一定的参考价值。

1、题目

给定一个二叉树，返回它的后序遍历。

示例:

输入: [1,null,2,3]  
   1
    \\
     2
    /
   3 

输出: [3,2,1]

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

2、思路1

(递归） $O (n)$

给定一个二叉树，返回它的后序遍历。

样例：

如样例所示，该二叉树的后序遍历为res = [9,5,7,4,3]，下面来讲解递归的做法。

二叉树的后序遍历顺序为：左->右->根，因此我们直接按照 左子树—>右子树—>根节点的方式遍历这颗二叉树。

递归函数设计：

void dfs(TreeNode* root)

root是当前访问的节点。

递归边界：

当访问到空节点时，结束本次递归调用。

具体过程如下：

1、定义res数组用来存贮访问后的节点。
2、从根节点root开始递归。
3、递归调用dfs(root->left)和dfs(root->right)来遍历当前root节点的左右子树。
4、将当前root节点的val值加入res数组中。

时间复杂度分析： $O (n)$ ，其中 $n$ 是二叉树的节点数。每一个节点恰好被遍历一次。

3、c++代码

/**
 * Definition for a binary tree node.
 * 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:
    vector<int>res;
    vector<int> postorderTraversal(TreeNode* root) {
        dfs(root);
        return res;
    }
    void dfs(TreeNode* root)
    {
        if(root == NULL) return;
        dfs(root->left);
        dfs(root->right);
        res.push_back(root->val);
    }
};

4、java代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    List<Integer> res = new ArrayList<Integer>();
    public List<Integer> postorderTraversal(TreeNode root) {
        dfs(root);
        return res;
    }
     public void dfs(TreeNode root)
    {
        if(root == null) return;
        dfs(root.left);
        dfs(root.right);
        res.add(root.val);
    }
}

5、思路2

(迭代) $O (n)$

迭代算法的本质是模拟递归，只不过递归使用了系统栈，而在迭代算法中我们使用stack模拟系统栈。在 144. 二叉树的前序遍历题中，我们已经知道了前序遍历二叉树的迭代写法，因此如何更改少量的代码实现二叉树的后序遍历？

二叉树的前序遍历顺序为：根->左->右，后序遍历的顺序为：左->右->根，我们将后序遍历的顺序颠倒过来为：根->右->左。因此我们只需要模拟前序遍历的过程，并将前序遍历中的左右子树遍历过程对换，最后将遍历得到的res数组翻转即可得到后序遍历的结果。

具体过程如下：

对于二叉树中的当前节点root：

1、将当前节点压入栈中，并记录到res数组中。
2、如果当前节点还有右儿子的话，继续将其右儿子压入栈中。
3、重复上述过程，直到最后一个节点没有右儿子为止。

这样，我们就将当前节点root和它的右侧子节点全部访问完毕了（相当于我们已经访问了根节点和右子树节点），栈中存放着当前节点和它的全部右侧子节点。接下来我们该要去访问当前节点的左子树了，由于栈是先进后出的，此时栈顶元素的左子节点就是下一个要遍历的节点，因此

1、取出栈顶元素的左子节点，并将其弹出栈。
2、如果当前栈顶元素的左子节点不为空，我们继续将其当成当前节点root，重复对当前节点root的处理过程。
3、最后将得到的res数组翻转。

时间复杂度分析： $O (n)$ ，其中 $n$ 是二叉树的节点数。每一个节点恰好被遍历一次。

6、c++代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while (root || stk.size()) {
            while (root) {
                res.push_back(root->val);
                stk.push(root);
                root = root->right;
            }
            root = stk.top()->left;
            stk.pop();
        }

        reverse(res.begin(), res.end());
        return res;
    }
};

7、java代码

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode() {}
*     TreeNode(int val) { this.val = val; }
*     TreeNode(int val, TreeNode left, TreeNode right) {
*         this.val = val;
*         this.left = left;
*         this.right = right;
*     }
* }
*/
class Solution {
   public List<Integer> postorderTraversal(TreeNode root) {
       List<Integer> res = new ArrayList<Integer>();
       Stack<TreeNode> stk = new Stack<TreeNode>();
       while(root != null || !stk.isEmpty())
       {
           while(root != null)
           {
               res.add(root.val);
               stk.add(root);
               root = root.right;
           }
           root = stk.pop();
           root = root.left;
       }
       Collections.reverse(res);
       return res;
   }
}