二叉树后序遍历

刚开始自己写的时候，没有使用栈结构对需要转变遍历子树节点进行存储，只是一直在想尽办法挪parent指针和当前的工作指针cur，结果屡试不爽，最后在github看到别人用了栈进行存储转换，遂理解记录了下来。

第一种方法：只用一个栈：

public static List<Integer> traverseWithStack1(TreeNode root){
		List<Integer> ret = new ArrayList<Integer>();
		if(root==null){
			return ret;
		}
		Stack<TreeNode> st = new Stack<TreeNode>();
		TreeNode cur = root.right;
		st.add(root);
		
		ret.add(root.val);
		while(!st.isEmpty()){
			while(cur!=null){
				ret.add(cur.val);
				st.add(cur);
				cur = cur.right;
			}
			TreeNode node = st.pop();
			cur = node.left;
			if(cur!=null){
				ret.add(cur.val);
				st.add(cur);
				cur = cur.right;
			}
		}
		int i=0;
		int j=ret.size()-1;
		while(i<j){
			int tmp = ret.get(i);
			ret.set(i, ret.get(j));
			ret.set(j, tmp);
			i++;
			j--;
		}
		return ret;
	}

算法说明：ret是用来存放最后遍历结果，st是用来存放转换左右子节点方向的父节点

算法步骤是：1.把根节点root压入栈

2.把每次遍历的右子树值压入栈

3.根节点的右子树根节点压入栈，直到右子树为叶子节点或者该节点只有一个左孩子

4.把刚才压栈的根节点（右子树上的）踢栈，采用上面同样方法遍历左子树

这样得到结果是ret中结果是中--右--左

最后在对ret中的结果进行一下对调。便可得到后序遍历的二叉树

第二种方法：用两个栈

public static List<Integer> postOrderTraverse(TreeNode root){
		//两个栈解决后序迭代遍历
		List<Integer> ret = new ArrayList<Integer>();
		//stChild用来存放节点的左右孩子，stRet用来翻转pop的结果
		Stack<TreeNode> stChild = new Stack<TreeNode>();
		Stack<TreeNode> stRet = new Stack<TreeNode>();
		if(root!=null){
			stChild.push(root);
			while(!stChild.isEmpty()){
				TreeNode cur = stChild.pop();
				stRet.push(cur);
				if(cur.left!=null){
					stChild.push(cur.left);
				}
				if(cur.right!=null){
					stChild.push(cur.right);
				}
			}
		}
		for(int i=stRet.size()-1;i>=0;i--){
			int res = stRet.pop().val;
			ret.add(res);
		}
		return ret;
	}

程序说明：

stChild用来存储每次遍历的根节点的两个孩子，stRet用来翻转最后的结果

算法步骤：

1.root压入stChild栈

2.判断孩子栈（stChild）中是否为空，为空就结束，不为空把栈顶的左右孩子压入孩子栈

3.将孩子栈中的元素逐一压入结果栈（刚好是左右还在对调，孩子栈中左孩子在下，有孩子在上，到了结果栈中时右孩子在下左在上）

4.打印结果栈

两种算法对比：

第二种算法明显易于理解，但占用较多的存储空间。