Binary Tree Postorder Traversal leetcode 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].

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

 

题解：

递归方法代码：

 1      public  void helper(TreeNode root, ArrayList<Integer> re){
 2          if(root== null)
 3              return;
 4         
 5         helper(root.left,re);
 6         helper(root.right,re);
 7         re.add(root.val);
 8     }
 9      public ArrayList<Integer> postorderTraversal(TreeNode root) {
10         ArrayList<Integer> re =  new ArrayList<Integer>();
11          if(root== null)
12              return re;
13         helper(root,re);
14          return re;
15     }

 非递归方法代码：

 引用自Code ganker：http://blog.csdn.net/linhuanmars/article/details/22009351

“接下来是迭代的做法，本质就是用一个栈来模拟递归的过程，但是相比于Binary Tree Inorder Traversal和Binary Tree Preorder Traversal，后序遍历的情况就复杂多了。我们需要维护当前遍历的cur指针和前一个遍历的pre指针来追溯当前的情况（注意这里是遍历的指针，并不是真正按后序访问顺序的结点）。具体分为几种情况：
（1）如果pre的左孩子或者右孩子是cur，那么说明遍历在往下走，按访问顺序继续，即如果有左孩子，则是左孩子进栈，否则如果有右孩子，则是右孩子进栈，如果左右孩子都没有，则说明该结点是叶子，可以直接访问并把结点出栈了。
（2）如果反过来，cur的左孩子是pre，则说明已经在回溯往上走了，但是我们知道后序遍历要左右孩子走完才可以访问自己，所以这里如果有右孩子还需要把右孩子进栈，否则说明已经到自己了，可以访问并且出栈了。
（3）如果cur的右孩子是pre，那么说明左右孩子都访问结束了，可以轮到自己了，访问并且出栈即可。
算法时间复杂度也是O(n)，空间复杂度是栈的大小O(logn)。实现的代码如下（代码引用自：http://www.programcreek.com/2012/12/leetcode-solution-of-iterative-binary-tree-postorder-traversal-in-java/）：”

 1      public ArrayList<Integer> postorderTraversal(TreeNode root) {
 2  
 3         ArrayList<Integer> lst =  new ArrayList<Integer>();
 4  
 5          if(root ==  null)
 6              return lst; 
 7  
 8         Stack<TreeNode> stack =  new Stack<TreeNode>();
 9         stack.push(root);
10  
11         TreeNode prev =  null;
12          while(!stack.empty()){
13             TreeNode curr = stack.peek();
14  
15              //  go down the tree.
16               // check if current node is leaf, if so, process it and pop stack,
17               // otherwise, keep going down
18               if(prev ==  null || prev.left == curr || prev.right == curr){
19                  // prev == null is the situation for the root node
20                   if(curr.left !=  null){
21                     stack.push(curr.left);
22                 } else  if(curr.right !=  null){
23                     stack.push(curr.right);
24                 } else{
25                     stack.pop();
26                     lst.add(curr.val);
27                 }
28  
29              // go up the tree from left node    
30               // need to check if there is a right child
31               // if yes, push it to stack
32               // otherwise, process parent and pop stack
33              } else  if(curr.left == prev){
34                  if(curr.right !=  null){
35                     stack.push(curr.right);
36                 } else{
37                     stack.pop();
38                     lst.add(curr.val);
39                 }
40  
41              // go up the tree from right node 
42               // after coming back from right node, process parent node and pop stack. 
43              } else  if(curr.right == prev){
44                 stack.pop();
45                 lst.add(curr.val);
46             }
47  
48             prev = curr;
49         }
50  
51          return lst;
52     }