【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?

 

例如以下列出三种解法：一种迭代的和两种iterative的

 

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

public class Binary_Tree_Postorder_Traversal {

	public static class TreeNode {
	       int val;
	       TreeNode left;
	       TreeNode right;
		   TreeNode(int x) { val = x; }
		}
	
	public static void main(String[] args) {	
        TreeNode r1 = new TreeNode(1);  
        TreeNode r2 = new TreeNode(2);  
        TreeNode r3 = new TreeNode(3);  
        TreeNode r4 = new TreeNode(4);  
        TreeNode r5 = new TreeNode(5);
        TreeNode r6 = new TreeNode(6);
          
        r1.left = r2;  
        r1.right = r3;  
        r2.left = r4;  
        r2.right = r5;  
        r3.right = r6; 

        List pr = postorderTraversal1(r1);
        
        int size = pr.size();
        
        System.out.println("the size is " + size);
        
        for (int i =0 ; i< size; i++) {
        	System.out.println(pr.get(i));
        }
	}
	
	public static List<Integer> postorderTraversal1(TreeNode root) {
		ArrayList<Integer> result = new ArrayList<Integer>();

		if (root == null)
			return result;

		result.addAll(postorderTraversal1(root.left));
		result.addAll(postorderTraversal1(root.right));
		result.add(root.val);

		return result;
	}

	public static List<Integer> postorderTraversal2(TreeNode root) { 
	    ArrayList<Integer> result = new ArrayList<Integer>();
	    Stack<TreeNode> stack = new Stack<TreeNode>();
	    Stack<TreeNode> output = new Stack<TreeNode>();
	    
	    if (root == null) return result;
	    
	    stack.push(root);
	    
	    while(!stack.empty()) {
	    	TreeNode cur = stack.pop();
	    	output.push(cur);
	    	
	    	if(cur.left != null) {
	    		stack.push(cur.left);
	    	}
	    	if(cur.right != null) {
	    	    stack.push(cur.right);	
	    	}
	    }
	    
	    while(!output.isEmpty()) {
	    	result.add(output.pop().val);
	    }
	    return result;
	}
	
	public List<Integer> postorderTraversal3(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();
	        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;
	}
}