二叉树后序遍历

 //分治
 public ArrayList<Integer> postorderTraversal(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<Integer>();
     if(root == null) return result;
    
     ArrayList<Integer> left = postorderTraversal(root.left);
     ArrayList<Integer> right = postorderTraversal(root.right);
     result.addAll(left);
     result.addAll(right);
     result.add(root.val);
     return result;
     
 }
 //非递归
 public ArrayList<Integer> postorderTraversal(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode prev = null; // previously traversed node
    TreeNode curr = root;

    if (root == null) {
        return result;
    }

    stack.push(root);
    while (!stack.empty()) {
        curr = stack.peek();
        //prev == null 也只是第一次root进来时有效，其它时候不可能为null
        if (prev == null || prev.left == curr || prev.right == curr) { // traverse down the tree
            if (curr.left != null) {
                stack.push(curr.left);
            } else if (curr.right != null) {
                stack.push(curr.right);
            }
        } else if (curr.left == prev) { // traverse up the tree from the left
            if (curr.right != null) {
                stack.push(curr.right);
            }
        } else { // traverse up the tree from the right
            result.add(curr.val);
            stack.pop();
        }
        prev = curr;
    }

    return result;
 }
 
 //游走遍历， 要返回的结果一直作为参数在传递
 public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        return    traverse(root, result);
  }
 private ArrayList<Integer> traverse(TreeNode root, ArrayList<Integer> result) {
     if(root == null) return result;
     traverse(root.left, result);
     traverse(root.right, result);
     result.add(root.val);
     return result;
 }

问题： 非递归解法还是看不懂~

http://www.lintcode.com/en/problem/binary-tree-postorder-traversal/

和中序类似的非递归写法：（中序：不用维护prev，不用考虑curr 和prev的关系，直接左子完了直接弹出root，再去看右子即可。）

public ArrayList<Integer> postorderTraversal(TreeNode root) {
       ArrayList<Integer>  result = new ArrayList<Integer> ();
       if(root == null) return result;
       Stack<TreeNode> stack = new Stack<TreeNode>();
       TreeNode temp = root;
       TreeNode prev = null;
       while(temp != null || !stack.empty()) {
           while(temp != null) {
                stack.push(temp);
                temp = temp.left;
           }
           temp = stack.peek();
           if(temp.right == null || temp .right == prev) {
               stack.pop();
               result.add(temp.val);
               prev = temp;
               temp = null;
               
           } else {
               prev = temp;
               temp = temp .right;
           }
           
       }
       return result;
   }

注意点：

　　　　prev除了第一次root进栈之前为空，之后和curr的关系由五种情况，即：

　　　　　　pre.left == curr , pre.right == curr  是树从定向下的过程

　　　　　　curr.left == prev 　　　　　　　　　　树从左子树向上的过程

　　　　　　curr.right == prev， curr == prev　　    curr== prev说明 curr的左右子树都为null或者说curr为叶结点，而且上一个循环刚经历pre.left == curr或者pre.right 　　　　　　　　　　　　　　　　　　　　　　　　　== curr的过程，而且没有往栈里添加元素（所以才说是叶结点），所以可以添加此curr的值到result中；

　　　　　　　　　　　　　　　　　　　　　　　　　树从右子树向上的过程说明curr的左子右子都已经进栈，已经经历过右子树的prev==curr的过程，即右子树已经添加到                                                                          result中，所以可以添加此curr到result中。

　　　　　　　　　　　　　　　　　　　　　　　　　　也即这两种情况都可以添加curr到result中。

错误点：