LeetCode解题报告:Binary Tree Postorder Traversal

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].

Note: Recursive solution is trivial, could you do it iteratively?

1.递归算法的递归定义是：

若二叉树为空，则遍历结束；否则
⑴ 后序遍历左子树(递归调用本算法)；
⑵ 后序遍历右子树(递归调用本算法) ；
⑶ 访问根结点 。

对有n个结点的二叉树，其时间复杂度均为O(n) 。

List<Integer> postOrder = new ArrayList<Integer>();
public List<Integer> postorderRecursion(TreeNode root) {
        if ((root != null) && (root.val != '#')) {
            postorderRecursion(root.left);
            postorderRecursion(root.right);
            postOrder.add(root.val);
        }
        return postOrder;
    }

2.非递归算法

   在后序遍历中，根结点是最后被访问的。因此，在遍历过程中，当搜索指针指向某一根结点时，不能立即访问，而要先遍历其左子树，此时根结点进栈。当其左子树遍历完后再搜索到该根结点时，还是不能访问，还需遍历其右子树。所以，此根结点还需再次进栈，当其右子树遍历完后再退栈到到该根结点时，才能被访问。

    因此，设立一个状态标志变量tag ：{ 0 ： 结点暂不能访问；1 ： 结点可以被访问}。

   其次，设两个堆栈S1、S2 ，S1保存结点，S2保存结点的状态标志变量tag 。S1和S2共用一个栈顶指针。

      设T是指向根结点的指针变量，非递归算法是：

若二叉树为空，则返回；否则，令p=T；

⑴ 第一次经过根结点p，不访问：

     p进栈S1 ， tag 赋值0，进栈S2，p=p->Lchild 。

⑵ 若p不为空，转(1)，否则，取状态标志值tag ：

 ⑶ 若tag=0：对栈S1，不访问，不出栈；修改S2栈顶元素值(tag赋值1) ，取S1栈顶元素的右子树，即p=S1[top]->Rchild ，转(1)；

⑷ 若tag=1：S1退栈，访问该结点；

直到栈空为止。

List<Integer> postOrder = new ArrayList<Integer>();
public List<Integer> postorderTraversal(TreeNode p) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<Boolean> tag = new Stack<Boolean>();
        while ((p != null) || !stack.isEmpty()) {
            if (p != null) {
                stack.push(p);
                tag.push(false);
                p = p.left;
            } else {
                boolean visit = tag.pop();
                if (visit) {
                    postOrder.add(stack.pop().val);
                } else {
                    tag.push(true);
                    p = stack.peek().right;
                }
            }
        }
        return postOrder;
    }

二叉树的三种遍历递归和非递归实现：递归实现都简单；非递归的前序和中序实现简单，后序采用2个栈来实现（参考严蔚敏的思路，比较容易理解）。代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

import javax.swing.text.AbstractDocument.LeafElement;

/**
 * Definition for binary tree public class TreeNode { int val; TreeNode left;
 * TreeNode right; TreeNode(int x) { val = x; } }
 */
public class TreeNodeSolution {

    public List<Integer> preorderRecursion(TreeNode root) {
        List<Integer> preOrder = new ArrayList<Integer>();
        if ((root != null) && (root.val != '#')) {
            preOrder.add(root.val);
            postorderRecursion(root.left);
            postorderRecursion(root.right);
        }
        return preOrder;
    }

    public List<Integer> inorderRecursion(TreeNode root) {
        List<Integer> inOrder = new ArrayList<Integer>();
        if ((root != null) && (root.val != '#')) {
            postorderRecursion(root.left);
            inOrder.add(root.val);
            postorderRecursion(root.right);
        }
        return inOrder;
    }

    public List<Integer> postorderRecursion(TreeNode root) {
        List<Integer> postOrder = new ArrayList<Integer>();
        if ((root != null) && (root.val != '#')) {
            postorderRecursion(root.left);
            postorderRecursion(root.right);
            postOrder.add(root.val);
        }
        return postOrder;
    }

    public List<Integer> inorderTraversal(TreeNode p) {
        List<Integer> inOrder = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while ((p != null) || !stack.isEmpty()) {
            if (p != null) {
                stack.push(p);
                p = p.left;
            } else {
                p = stack.pop();
                inOrder.add(p.val);
                p = p.right;
            }
        }
        return inOrder;
    }

    public List<Integer> preorderTraversal(TreeNode p) {
        List<Integer> preOrder = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while ((p != null) || !stack.isEmpty()) {
            if (p != null) {
                preOrder.add(p.val);
                stack.push(p);
                p = p.left;
            } else {
                p = stack.pop();
                p = p.right;
            }
        }
        return preOrder;
    }

    public List<Integer> postorderTraversal(TreeNode p) {
        List<Integer> postOrder = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<Boolean> tag = new Stack<Boolean>();
        while ((p != null) || !stack.isEmpty()) {
            if (p != null) {
                stack.push(p);
                tag.push(false);
                p = p.left;
            } else {
                boolean visit = tag.pop();
                if (visit) {
                    postOrder.add(stack.pop().val);
                } else {
                    tag.push(true);
                    p = stack.peek().right;
                }
            }
        }
        return postOrder;
    }

    public static void main(String[] args) {
        TreeNode t1 = new TreeNode(1);
        TreeNode t2 = new TreeNode(2);
        TreeNode t3 = new TreeNode(3);
        t1.setRight(t2);
        t1.setLeft(t3);
        System.out.println(new TreeNodeSolution().postorderTraversal(t1));
    }
}