LeetCode145 Binary Tree Postorder Traversal（迭代實現） Java

題目：
Given a binary tree, return the postorder traversal of its nodes’ values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [3,2,1].

分析：
爲了幫助讀者理解LeetCode341 Flatten Nested List Iterator（迭代器模式實踐） ，本文給出基於迭代的方式後根遍歷二叉樹的實現。具體的思路可以從代碼中詳盡的註釋中看到。

代碼：

package leetcode145;

import java.util.LinkedList;
import java.util.List;

import global.TreeNode;

public class LeetCode145 {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<Integer>();
        if (root == null) {
            return result;
        }
        LinkedList<TreeNodeWithFlag> stack = new LinkedList<TreeNodeWithFlag>();
        // 首先，從根節點開始，往左下方走，一直走到頭，將路徑上的每一個結點入棧。
        TreeNode cursor1 = root;
        while (cursor1 != null) {
            stack.push(new TreeNodeWithFlag(cursor1, false));
            cursor1 = cursor1.left;
        }
        while (!stack.isEmpty()) {
            TreeNodeWithFlag top = stack.peek();

            // 注意，任意一個結點N，只要他有左孩子，則在N入棧之後，
            // N的左孩子必然也跟着入棧了(這個體現在算法的後半部分)，
            // 所以當我們拿到棧頂元素的時候，可以確信這個元素要麼沒有左孩子，
            // 要麼其左孩子已經被訪問過，所以此時我們就不關心它的左孩子了，我們只關心其右孩子。

            // 若其右孩子已經被訪問過，或是該元素沒有右孩子，則由後序遍歷的定義，此時可以visit這個結點了。
            if (top.treeNode.right == null || top.flag == true) {
                stack.pop();
                result.add(top.treeNode.val);
            } else {
                // 若它的右孩子存在且top.flag爲false，說明以前還沒有動過它的右孩子，於是就去處理一下其右孩子。
                // 此時我們要從其右孩子結點開始一直往左下方走，直至走到盡頭，將這條路徑上的所有結點都入棧。

                // 當然，入棧之前要先將該結點的top.flag設成true，因爲其右孩子的入棧
                // 意味着它的右孩子必將先於它被訪問(這很好理解，因爲我們總是從棧頂取出元素來進行visit)。
                // 由此可知，下一次該元素再處於棧頂時，其右孩子必然已被visit過了，所以此處可以將top.flag設置爲true。
                top.flag = true;
                TreeNode cursor2 = top.treeNode.right;
                while (cursor2 != null) {
                    stack.push(new TreeNodeWithFlag(cursor2, false));
                    cursor2 = cursor2.left;
                }
            }

        }
        return result;
    }

    private static class TreeNodeWithFlag {
        private TreeNode treeNode;
        // 表示該節點的右子樹是否被訪問過
        private boolean flag;

        private TreeNodeWithFlag(TreeNode treeNode, boolean flag) {
            super();
            this.treeNode = treeNode;
            this.flag = flag;
        }

        public TreeNode getTreeNode() {
            return treeNode;
        }

        public void setTreeNode(TreeNode treeNode) {
            this.treeNode = treeNode;
        }

        public boolean isFlag() {
            return flag;
        }

        public void setFlag(boolean flag) {
            this.flag = flag;
        }

        @Override
        public String toString() {
            return "TreeNodeWithFlag [treeNode=" + treeNode + ", flag=" + flag
                    + "]";
        }

    }

    public static void main(String[] args) {
        LeetCode145 leetCode145 = new LeetCode145();
        TreeNode treeNode1 = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        treeNode1.left = treeNode2;
        System.out.println(leetCode145.postorderTraversal(treeNode1));
    }
}

package global;

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(int x) {
        val = x;
    }

    @Override
    public String toString() {
        return "TreeNode [val=" + val + ", left=" + left + ", right=" + right
                + "]";
    }

}