二叉树非递归遍历（前序，后序），java实现

题目  Binary Tree Preorder Traversal  Binary Tree Postorder Traversal

题目要求就是通过非递归的方法遍历二叉树，结果保存在一个List里

做这个题的时候也上网看了一些实现，http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html，跟我开始的思路就不太一样，我也想到用栈来模拟递归，可是看见别人的实现怎么感觉不到是在模拟递归呢，跟递归方法的结构一点都不像了呢。。。

下面说说我写的模拟递归。。。

前序遍历

递归版本很简单

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> l = new ArrayList<Integer>();
        
        if(root == null)
            return l;
        l.add(root.val);
        l.addAll(preorderTraversal(root.left));
        l.addAll(preorderTraversal(root.right));
        return l;
    }
}

非递归版本

public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> l = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        HashSet<TreeNode> visited = new HashSet<TreeNode>();		//用一个集合来记录节点是否被访问过，在集合内表示被访问过

        if(root == null)
        	return l;
        stack.push(root);
        l.add(root.val);		//先根序，首先访问根，在这里就是加入到List中
        while(!stack.isEmpty())
        {
        	TreeNode node = stack.peek();
        	if(node.left != null && !visited.contains(node.left))		//如果左孩子存在并且没被访问过，就访问左孩子
        	{
        		stack.push(node.left);		//下面几行代码，访问了左孩子，并把访问顺序往左孩子延伸
        		node = node.left;
        		visited.add(node);
        		l.add(node.val);
        		continue;
        	}

        	if(node.right != null && !visited.contains(node.right))		//同上
        	{
        		stack.push(node.right);		//同上
        		node = node.right;
        		visited.add(node);
        		l.add(node.val);
        		continue;
        	}

        	stack.pop();	//能到这行，表示当前栈顶元素左右孩子或者为空或者被访问过，因此要弹出
        }
        return l;
    }
}

执行的流程就是先访问当前节点，然后把当左孩子作为当前节点，左孩子为空或者被访问过就把右孩子作为当前节点，如果右孩子还是空或者访问过，就说明要往回走了，即弹栈

后序遍历

先看看递归版本

public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> l = new ArrayList<Integer>();
        if(root == null)
            return l;
        else
        {
            l.addAll(postorderTraversal(root.left));
            l.addAll(postorderTraversal(root.right));
            l.add(root.val);
            return l;
        }
    }
}

模仿递归版本的样子，写非递归版本

public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> l = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        HashSet<TreeNode> visited = new HashSet<TreeNode>();
        
        if(root == null)
            return l;
        else
        {
        	stack.push(root);
        	visited.add(root);
        	while(!stack.isEmpty())
        	{
        		TreeNode node = stack.peek();
	        	if(node.left != null && !visited.contains(node.left))
	        	{
	        		stack.push(node.left);
	        		node = node.left;
	        		visited.add(node);
	        		continue;
	        	}
	        	if(node.right != null && !visited.contains(node.right) )
	        	{
	        		stack.push(node.right);
	        		node = node.right;
	        		visited.add(node);
	        		continue;
	        	}
	        	stack.pop();//后根序，所以在弹栈返回到根的时候才访问它
	        	l.add(node.val);
        	}
            return l;
        }
    }
}

后序的实现和先序的实现形式差不多，看起来舒服多了。

中根序的话把弹栈和访问的两行代码放在两个if中间就行了吧。。。没试过。。