LeetCode 145. Binary Tree Postorder Traversal

题目：

Given the root of a binary tree, return the postorder traversal of its nodes' values.

Example 1:

Input: root = [1,null,2,3]
Output: [3,2,1]

Example 2:

Input: root = []
Output: []

Example 3:

Input: root = [1]
Output: [1]

Example 4:

Input: root = [1,2]
Output: [2,1]

Example 5:

Input: root = [1,null,2]
Output: [2,1]

Constraints:

• The number of the nodes in the tree is in the range [0, 100].
• -100 <= Node.val <= 100

Follow up:

Recursive solution is trivial, could you do it iteratively?

---

很普通的后序遍历，不写递归了。这个咋比pre和in难这么多啊QAQ

2023.1.6 还是贴个递归吧

/**
 * 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> result = new ArrayList<>();
        postorder(root, result);
        return result;
    }

    private void postorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        postorder(root.left, result);
        postorder(root.right, result);
        result.add(root.val);
    }
}

---

迭代如果严格按照后序遍历的写，有一点点复杂。有个最简单的方法就是我们考虑到前序遍历是：root->left->right，后序遍历是left->right->root。如果我们把前序遍历改成root->right->left，那么最后把结果倒过来不就是后序遍历了。于是，我们就可以非常无脑地把前序遍历里的right和left换一下，最后输出前Collections.reverse()一下，嗯，完美。（前序笔记里两种方法都可以哦）

Runtime: 1 ms, faster than 27.52% of Java online submissions for Binary Tree Postorder Traversal.

Memory Usage: 37.2 MB, less than 98.98% of Java online submissions for Binary Tree Postorder Traversal.

/**
 * 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) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack = new ArrayDeque<>();
        stack.add(root);
        while (!stack.isEmpty()) {
            TreeNode curr = stack.pop();
            result.add(curr.val);
            if (curr.left != null) {
                stack.push(curr.left);
            }
            if (curr.right != null) {
                stack.push(curr.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

然后又看了一下关于上面这种reverse的分析：

1. 用LinkedList的话reverse会更快，空间也是O(1)

2.  如果用LinkedList的话可以直接list.addFirst插入到链表头，就不需要reverse了

---

2023.1.6

根据110里看了老半天才弄懂的postorder iteration写法，自己写出来了。总结一下，和preorder不一样的地方就在于：

1. 需要一个set来存放看到过的node

2. 不能直接pop stack top，而需要先peek，等到最后才pop它

if不是并列的，而是if / else if / else的结构，原因是需要能push left尽量push left，只有回来以后（左边的都见过了以后）才考虑右边的。

/**
 * 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> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Set<TreeNode> seen = new HashSet<>();
        Deque<TreeNode> stack = new ArrayDeque<>();
        stack.push(root);
        seen.add(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.peek();
            if (node.left != null && !seen.contains(node.left)) {
                stack.push(node.left);
                seen.add(node.left);
            } else if (node.right != null && !seen.contains(node.right)) {
                stack.push(node.right);
                seen.add(node.right);
            } else {
                node = stack.pop();
                result.add(node.val);
            }
            
        }
        return result;
    }
}

---

2023.1.6

再贴一个类似inorder的push all left nodes的方法好了。其实和上面的本质有点像。至于存放见过的，既可以用seen set，当然也可以用一个last变量来存上一个见过的节点来判断是不是回去root了。

push all left nodes的while循环类似于上面写法的第一个if。同样也只能先peek因为不能先把root给pop掉。然后如果是有右子树并且不是从右边来的（last != node.right），那就对它的右子树进行上述操作（就是curr = node.right）；否则说明该把当前node加入list了，并update一下last，也别忘了给它pop出来。

/**
 * 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> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Deque<TreeNode> stack = new ArrayDeque<>();
        TreeNode last = null;
        TreeNode curr = root;
        while (!stack.isEmpty() || curr != null) {
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
            }

            TreeNode node = stack.peek();
            System.out.println(node.val);
            if (node.right != null && node.right != last) {
                curr = node.right;
            } else {
                node = stack.pop();
                result.add(node.val);
                last = node;
            }
        }
        return result;
    }
}

---

其他做法简单看了下，过于复杂，暂时战略性放弃。（2023.1.6 依旧是战略性放弃）145*. Binary Tree Postorder Traversal · leetcode这里讲得很好了。