LeetCode145.二叉树的后序遍历

/**
 * 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<>();

    // 时间 O(n) 空间 O(n)
    public List<Integer> postorderTraversal(TreeNode root) {

        Stack<TreeNode> stack = new Stack();
        List<Integer> res = new ArrayList();

        while(!stack.isEmpty() || root != null){
       //1. 每次将当前节点压入栈中，如果当前节点有左子树，就往左子树跑，没有左子树就往右子树跑。
      // 2.若当前节点无左子树也无右子树，从栈中弹出该节点并且打印出来， 如果当前节点是上一个节点的左节点，
    //尝试访问上个节点的右子树，如果不是，那当前栈的栈顶元素继续弹出。

            while(root != null){
                stack.push(root);
                if(root.left != null){
                    root = root.left;
                }else{
                    root = root.right;
                }
            }
            root = stack.pop();
            res.add(root.val);
            if(!stack.isEmpty() && root == stack.peek().left){
                root = stack.peek().right;
            }else{
                root = null;
            }

        }
        return res;
    }
}

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        res = []

        while stack or root:
            while root:
                stack.append(root)
                if root.left:
                    root = root.left
                else:
                    root = root.right

            root = stack.pop()
            res.append(root.val)

            if stack and root == stack[-1].left:
                root = stack[-1].right
            else:
                root = None

        return res

/**
 * 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> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;

        while(!st.empty() || root){
            while(root){
                st.push(root);
                if(root->left){
                    root = root->left;
                }else{
                    root = root->right;
                }
            }

            root = st.top();
            st.pop();
            res.push_back(root->val);

            if(!st.empty() && root == st.top()->left){
                root = st.top()->right;
            }else{
                root = nullptr;
            }
        }

        return res;
    }
};

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    stack := []*TreeNode{}
    res := []int{}

    for len(stack) > 0 || root != nil {
        for root != nil {
            stack = append(stack, root)
            if root.Left != nil {
                root = root.Left
            } else {
                root = root.Right
            }
        }

        root = stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, root.Val)

        if len(stack) > 0 && root == stack[len(stack)-1].Left {
            root = stack[len(stack)-1].Right
        } else {
            root = nil
        }
    }

    return res
}