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));
     }
 }