二叉树遍历

1. 定义

分三种：

1. 先序遍历：先访问根节点，然后是左孩子，然后是右孩子（根，左，右）
2. 中序遍历：左，根，右
3. 后序遍历：左，右，根
4. 层次遍历：从根节点开始，从上至下逐层遍历，同一层中，按从左至右顺序遍历

2. 递归解法

树表现为一种链表结构，链表问题大都可以采用递归实现。树更是常常有递归解法。

先、中、后遍历的递归写法同定义一致，再次不在赘述，可参照后边的代码理解。

层次遍历用递归好像不太直观吧，一般都是用队列迭代，具体也在下边介绍。

3. 非递归解法---迭代法

递归解法一般都对应有非递归解法（用栈来模拟递归过程，实现迭代）。

并非所有程序设计语言都允许递归；此外，大量递归可能造成栈溢出，所以有时需要提供非递归解法，即迭代解法，效率更高一些。

先、中、后遍历，在遍历节点时经过的路径其实是一样的，只是访问时机不同：从根节点沿左子树深入下去，深入不下去就返回，再从刚才深入时的右子树开始，继续之前的深入和返回。直到最后从根节点的右子树返回根节点为止

1. 先序遍历：深入时，遇到节点就访问-------节点不空，入栈访问，遍历左子树；否则遍历右子树
2. 中序遍历：从左子树返回时访问-----------节点不空，遍历左子树；否则出栈访问，遍历右子树
3. 后续遍历：从右子树返回时访问-----------节点不空，遍历左子树；否则，如果是从左子树返回，遍历右子树，如果是从右子树返回，出栈访问

中序和后序看着差不多，而实现起来后序遍历略复杂（可能因为中序遍历完右子树就结束了，没有操作了，但是后序遍历完左子树和右子树都有操作，而且操作还不同），需要标志是否右子树都被访问了。可以对每个节点加一个标志位，标志右子树是否被访问了，也可以用一个变量来表示，具体看实现代码。

层次遍历：采用队列，将根节点入队列。队列不空时，取队首节点访问，并将队首节点的所有子节点入队列。直至队列为空。

参考资料：http://www.cztvu.ah163.net/czcai/soft/kj/sjjg/jj/ch6.htm

代码：

package BinaryTree;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.List;
import java.util.Scanner;

/**
 * @author 
 * @date 2015年9月16日
 */

class TreeNode{
    public int val;
    public TreeNode left;
    public TreeNode right;
    
    public TreeNode( int val ){
        this.val = val;
    }
    
    public static TreeNode createTree(){
        Scanner in = new Scanner( System.in );
        TreeNode root = null;
        int val = in.nextInt();
        if( val != '#' ){
            root = new TreeNode(val);
            root.left = createTree();
            root.right = createTree();
        }
        in.close();
        return root;
    }
    
    //the recursion version of preOrder
    public void preOrderRec( TreeNode root, List<Integer> res ){
        if( root != null ){
            res.add(root.val);
            preOrderRec( root.left, res );
            preOrderRec( root.right, res );
        }
    }
    
    //the recursion version of inOrder
    public void inOrderRec( TreeNode root, List<Integer> res ){
        if( root != null ){
            inOrderRec( root.left, res );
            res.add( root.val );
            inOrderRec( root.right, res );
        }
    }
    
    //the recursion version of postOrder
    public void postOrderRec( TreeNode root, List<Integer> res ){
        if( root != null ){
            postOrderRec( root.left, res );
            res.add( root.val );
            postOrderRec( root.right, res );
        }
    }
    
    /*
     * the non-recursion version of preOrder using stack.  
     * When present node (present root) is not null, push and traverse left subtree.
     * Visit when push.
     * When present node (present root) is null, pop and traverse right subtree.
     */
    public void preOrder( TreeNode root, List<Integer> res ){
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        TreeNode p = root;
        while( p!=null || !stack.isEmpty() ){
            if( p != null ){
                stack.push(p);
                //visit root-----1
                res.add(p.val);
                //traverse the left subTree-----2
                p = p.left;
            }
            else{
                p = stack.pop();
                //traverse the right subTree-----3
                p = p.right;
            }
        }
    }
    
    //the non-recursion version of inOrder using stack. Similar to preOrder except that it visits when pop.
    public void inOrder( TreeNode root, List<Integer> res ){
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        TreeNode p = root;
        while( p != null || !stack.isEmpty() ){
            if( p != null ){
                stack.push(p);
                //traverse the left subtree------1
                p = p.left;
            }
            else{
                p = stack.pop();
                //visit the root------2
                res.add(p.val);
                //traverse the right subtree-----3
                p = p.right;
            }
        }
    }
    
    /*
     * the non-recursion version of postOrder using stack. This is more complicated. It only visits when return from the right subree.
     * When present node (present root) is not null, push and traverse the left subtree
     * When present node (present root) is null, pop.
     *     (1)If only the left subtree is visited, then push the right subtree.
     *     (2)Else, that is, both the left and right subtree are visited, then visit when pop.
     * 
     * First implementation (after pushed, the root is in fact traversed twice: once when return from left, once when return from right.
     * So we can try to push and pop every root twice):
     * For the above (1) step, push the present root again and traverse the right subtree. 
     * For the above (2) step, visit when the second pop.
     */
    public void postOrder1( TreeNode root, List<Integer> res ){
        Deque<TreeNodeWithTag> stack = new ArrayDeque<TreeNodeWithTag>();
        TreeNode p = root;
        while( p != null || !stack.isEmpty() ){
            if( p != null ){
                //first push
                stack.push( new TreeNodeWithTag( p, false) );
                //traverse the left subtree-----1
                p = p.left;
            }
            else{
                //pop
                TreeNodeWithTag top = stack.pop();
                if( !top.tag ){
                    //second push
                    top.tag = true;
                    stack.push(top);
                    //traverse the right subtree------2
                    p = top.node.right;
                }
                else{
                    //visit the root------3
                    res.add(top.node.val);
                }
            }
        }
    }
    
    /*
     * The second implementation of postOrder. Similar to postOrder1 using the assistant tag for every node.
     * When the present node is not null, push to traverse the left nodes;
     * If present node is null, if top.right has not been visited, traverse the right subtree
     * Else if top.right has been visited, pop and visit the root
     */
    public void postOrder2( TreeNode root, List<Integer> res ){
        Deque<TreeNodeWithTag> stack = new ArrayDeque<TreeNodeWithTag>();
        TreeNode p = root;
        while( p != null || !stack.isEmpty() ){
            while( p != null ){
                //traverse the left nodes
                stack.push( new TreeNodeWithTag( p, false) );
                p = p.left;
            }
            if( !stack.isEmpty() && !stack.peek().tag ){
                //traverse the right nodes
                stack.peek().tag = true;
                p = stack.peek().node.right;
            }
            else if( !stack.isEmpty() ){
                //visit the root
                res.add( stack.pop().node.val );
            }
        }
    }
    /*
     * The third implementation of postOrder. Use only one tag to check the previous condition.
     * If no return, traverse the left subtree
     * Else if return from left, traverse the right subtree
     * else if return from right, visit the root
     */
    public void postOrder3( TreeNode root, List<Integer> res ){
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        boolean rightVisited = false;
        TreeNode p = root;
        while( p != null || !stack.isEmpty() ){
            if( p != null ){
                //traverse the left subtree
                stack.push(p);
                p = p.left;
                rightVisited = false;
            }
            else if( !rightVisited ){
                //traverse the right subtree
                p = stack.peek().right;
                rightVisited = true;
            }
            else if( rightVisited ){
                //visit the root
                TreeNode top = stack.pop();
                res.add( top.val );
                if( !stack.isEmpty() && stack.peek().left == top )
                    rightVisited = false;
            }            
        }
    }
    
    /*
     * The fourth implementation of postOrder. Use only one tag to check the previous condition.
     */
    public void postOrder4( TreeNode root, List<Integer> res ){
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        boolean rightVisited = false;
        TreeNode p = root;
        while( p!=null || !stack.isEmpty() ){
            if( p!=null ){
                //traverse the left subtree
                do{
                    stack.push(p);
                    p = p.left;                    
                }while( p!=null );
                rightVisited = false;
            }
            if( !rightVisited ){
                //traverse the right subtreee
                p = stack.peek().right;
                rightVisited = true;
            }
            else{
                //visit the root
                TreeNode top = stack.pop();
                res.add( top.val );
                if( !stack.isEmpty() && stack.peek().left == top )
                    rightVisited = false;
            }
        }
    }
    //level order. Use queue.
    public void levelOrder( TreeNode root, List<Integer> res ){
        Deque<TreeNode> queue = new ArrayDeque<TreeNode>();
        queue.add(root);
        while( !queue.isEmpty() ){
            TreeNode p = queue.remove();
            res.add(p.val);    //visit up level
            if( p.left != null )    queue.add(p.left);
            if( p.right != null )    queue.add(p.right);
        }
    }
    
}

//used by postOrder1 and postOrder to tag if the left subtree or the right subtree is visited.
class TreeNodeWithTag{
    TreeNode node;
    boolean tag;    //false represents return from left subtree (the first push and pop), true represents return from the right subtree (the second push and pop)
    public TreeNodeWithTag( TreeNode node, boolean value ){
        this.node = node;
        this.tag = value;        
    }
}