树的前序后序中序遍历

在计算机科学里，树的遍历是指通过一种方法按照一定的顺序访问一颗树的过程。

对于二叉树，树的遍历通常有四种：先序遍历、中序遍历、后序遍历、广度优先遍历。（前三种亦统称深度优先遍历）对于多叉树，树的遍历通常有两种：深度优先遍历、广度优先遍历。

在学习前面三种深度优先遍历之前，很有必要了解它们之间到底是怎么遍历的，要自己去亲自去遍历，不要只看文字

先序遍历：  节点 - 左孩子 - 右孩子

中序遍历： 左孩子  - 根结点 - 右孩子

后序遍历 ： 左孩子 - 右孩子 - 根结点

看下面的图（自己去写出几种遍历的情况）：

 

按照上面的三种方法去遍历，结果是

前序遍历：- + a * b – c d / e f
中序遍历：a + b * c – d – e / f
后序遍历：a b c d – * + e f / -

广度优先遍历，又叫层次遍历：从二叉树的第一层（根结点）开始，自上至下逐层遍历；在同一层中，按照从左到右的顺序对结点逐一访问。

在这幅图里所的结果是：- + / a * c f b – c d

下面给出java实现上面几种遍历的算法以及解释:

三种递归的算法不说了，直接说非递归算法：

前序非递归实现 

节点 - 左孩子 - 右孩子
     1)访问结点P，并将结点P入栈;
     2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
     3)直到P为NULL并且栈为空，则遍历结束。

有两种实现方法：

public static void preOrder1_1(BinTree t){
        Stack<BinTree> s = new Stack<BinTree>();
        while(t != null || !s.empty()){       //只要满足节点非空或则栈为非空，就要不断遍历
            
            while(t !=null ){                 //压入所有左孩子节点，压入前输出
                System.out.print(t.date);
                s.push(t);
                t = t.lchild;
            }
            if(!s.empty()){        //左孩子都搞定了，从栈顶取出一个节点，指向它的右孩子，继续前面while循环
                t = s.pop();
                t = t.rchild;
            }
        }
        System.out.println();
    }
    public static void preOrder1_2(BinTree t){
        Stack<BinTree> stack = new Stack<BinTree>();
        if(t!=null)
        {
            stack.push(t);
            while(!stack.empty())
            {
                t = stack.pop();
                System.out.print(t.date);
                if(t.rchild!=null)         //先把右孩子压入栈，利用下压栈的特性
                    stack.push(t.rchild);
                if(t.lchild!=null)
                    stack.push(t.lchild);                
            }
        }
    }

中序非递归算法：

  左孩子  - 根结点 - 右孩子
     *访问任意一节点p，若其左孩子非空，p入栈，且p的左孩子作为当前节点，然后在对其进行同样的处理
     *若其左孩子为空，则输出栈顶点元素并进行出栈操作，访问该栈顶的节点的右孩子
     *直到p为null并且栈为空则遍历结束
   (和前序的非递归算法1_1有相似之处）

public static void InOrder2_1(BinTree t){
        Stack<BinTree> s = new Stack<BinTree>();
        while(t != null || !s.empty()){
            while(t !=null){           //和前序的非递归有点像
                s.push(t);
                t = t.lchild;           //一路指向左孩子
            }
            if(! s.empty()){
                t = s.pop();              //取栈顶元素并输出，并指向右孩子
                System.out.print(t.date);
                t = t.rchild;
            }
        }
        System.out.println();
    }

后序非递归算法

左孩子 - 右孩子 - 根结点

这个有难度  因为要保证左孩子和右孩子都已经被访问过了才访问根节点,这里就要思考一下如何标记一下右孩子是否已经被标记了。有两种方法：

双栈法（这个比较容易理解）
     * 对于跟节点t，先入栈，然后沿着其左子树往下收索，直到没有左子树的节点，此时该节点入栈
     * 但此时不能进行出栈访问，要检查右孩子，所以接下来一相同的规则进行处理，当访问其右孩子时，
     * 该节点又出现在栈顶，此时就可以出栈访问，这样就保证了正确的访问顺序，这个过程中，
     * 每个节点都两次出现在栈顶，只有在第二次出现在栈顶的时候才能访问它， 因此有必要设置两个栈

public static void PostOrder3_1(BinTree t){
        Stack<BinTree> s = new Stack<BinTree>();
        Stack<Integer> s2 = new Stack<Integer>();   
        Integer i = new Integer(1);        //第二个栈有0 1 俩元素，1表示第二次访问，0,表示第一次访问
        while(t!=null || !s.empty()){
            while(t!=null){               //一路压入左孩子
                s.push(t);                  
                s2.push(new Integer(0));
                t = t.lchild;
            }
            //peek查看堆栈顶部的对象，但不从堆栈中移除它。
            while(!s.empty() && s2.peek().equals(i)){  //有两次访问的记录了，就出栈且输出啦，俩栈是同步pop的
                s2.pop();
                System.out.print(s.pop().date);
            }
            if(!s.empty()){         //第二次访问了，栈2的元素置为1，这回要指向右孩子
                s2.pop();
                s2.push(new Integer(1));
                t = s.peek();
                t = t.rchild;
            }
        }
    }

单栈法：

     * 先扫描跟节点的所有左节点并入栈，接着将栈顶元素出栈，
     * 再扫描该节点的右孩子节点并入栈，扫描右孩子的所有左节点并入栈，当一个节点的左右孩子均被访问后在访问该节点，
     * 这里用一个初始值为null的节点表示右子树刚刚被访问的
     * 一直到栈为空，这里的难点是如何判断右孩子已经被访问过了
     这个构造真的是太赞了！！

public static void PostOrder3_2(BinTree t){
        BinTree q = null;
        Stack<BinTree> stack = new Stack<BinTree>();
        while(t!=null)
        {    
            while(t.lchild!=null)            //先左子树入栈,注意:这里最左节点（叶子）没有入栈，后面才入栈
            {
                stack.push(t);
                t = t.lchild;
            }
            while(t.rchild==null || t.rchild ==q )
            {            
                System.out.print(t.date);   //当前节点无右孩子或者右孩子已经输出
                q = t;                      //用来记录上一个节点
                if(stack.empty())
                    return ;               //栈为空时，就结束程序
                t = stack.pop();           //节点出栈
            }        
            stack.push(t);           //！1、叶子节点入栈，指向的r.child是null 2、处理右孩子
            t = t.rchild;
        }
    }

另外一个单栈实现，单栈的构造都好神奇！

public static void PostOrder3_3(BinTree t){
        BinTree node = t, prev = t;
        Stack<BinTree> stack = new Stack<BinTree>();
        while(node != null || stack.size()>0)
        {
            while(node!=null)               //压入左孩子
            {
                stack.push(node);
                node = node.lchild;
            }
            if(!stack.empty())
            {
                BinTree temp = stack.peek().rchild;  //记录当前节点的右孩子
                if((temp == null)||temp == prev)
                {
                    node = stack.pop();           //满足俩条件就出栈输出
                    System.out.print(node.date);
                    prev = node;               //标记已经被访问
                    node = null;               //把这个没用的节点置为null.，防止执行上面的while循环
                } 
                else{
                    node = temp;
                }
            }        
        }
    }

如果用数组去实现stack的话，可以用这个，这个是在求解两节点个最近公共祖先时用到的（LCA算法），改写自考研书上

//栈是用数组实现的 后序非递归算法，数组里含有所有的元素
    public static void  PostOrder3_4(BinTree t)
    {
            BinTree st[] = new BinTree[1000];        //用数组实现顺序栈    
            int flag,top=-1;                         //栈指针初始化
            BinTree p =t,q;
            do
            {
                while(p!=null)                  //将p的所有左节点入栈
                {
                    top++;
                    st[top] = p;
                    p = p.lchild;
                } 
                q = null;                       //q指向栈顶节点的前一个已经访问的节点
                flag = 1;                       //设置flag = 1表示处理栈顶节点            
                while(top !=-1 && flag ==1)
                {
                    p = st[top];                //取出栈顶的元素
                    if(p.rchild==q)             //右孩子不存在或者右孩子已经被访问，访问之
                    {
                        System.out.print(p.date);
                        top--;
                        q=p;                    //q指向刚刚被访问的节点
                    }
                    else
                    {    
                        p = p.rchild;           //p指向右孩子节点
                        flag =0;                //flag=0表示栈顶节点处理完毕
                    }                        
                }            
        }while(top!=-1);                       //栈不为空时循环
        System.out.println(); 
    }

下面是全部的代码外加一个测试实例：

/***************************************
 * 时间：2013年12月2日
 * author：lm
 * 内容：二叉树前中后递归与非递归遍历，以及广度优先遍历
 ***************************************/
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Stack;

public class BinTree {
    private char date;
    private BinTree lchild;   //左孩子
    private BinTree rchild;   //右孩子
    
    private BinTree(char c ){
        date = c;
    }
    
    //先序遍历 递归实现  节点 - 左孩子 - 右孩子
    public static void preOrder1(BinTree t){
        if(t != null){
        System.out.print(t.date);
        preOrder1(t.lchild);
        preOrder1(t.rchild);
        }
    }
    
    //中序遍历 递归实现 左孩子  - 根结点 - 右孩子
    public static void InOrder2(BinTree t){
        if(t != null){    
        InOrder2(t.lchild);
        System.out.print(t.date);
        InOrder2(t.rchild);
        }
    }
    
    //后序遍历  递归实现  左孩子 - 右孩子 - 根结点
    public static void PostOrder3(BinTree t){
        if(t!=null)
        {
            PostOrder3(t.lchild);
            PostOrder3(t.rchild);
            System.out.print(t.date);
        }
    }
    
    /*前序非递归实现    节点 - 左孩子 - 右孩子
     1)访问结点P，并将结点P入栈;
     2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，
              循环至1);若不为空，则将P的左孩子置为当前的结点P;
     3)直到P为NULL并且栈为空，则遍历结束。
     */
    
    public static void preOrder1_1(BinTree t){
        Stack<BinTree> s = new Stack<BinTree>();
        while(t != null || !s.empty()){       //只要满足节点非空或则栈为非空，就要不断遍历
            
            while(t !=null ){                 //压入所有左孩子节点，压入前输出
                System.out.print(t.date);
                s.push(t);
                t = t.lchild;
            }
            if(!s.empty()){        //左孩子都搞定了，从栈顶取出一个节点，指向它的右孩子，继续前面while循环
                t = s.pop();
                t = t.rchild;
            }
        }
        System.out.println();
    }
    public static void preOrder1_2(BinTree t){
        Stack<BinTree> stack = new Stack<BinTree>();
        if(t!=null)
        {
            stack.push(t);
            while(!stack.empty())
            {
                t = stack.pop();
                System.out.print(t.date);
                if(t.rchild!=null)         //先把右孩子压入栈，利用下压栈的特性
                    stack.push(t.rchild);
                if(t.lchild!=null)
                    stack.push(t.lchild);                
            }
        }
    }
    
    /*中序非递归的实现  左孩子  - 根结点 - 右孩子
     * 访问任意一节点p，若其左孩子非空，p入栈，且p的左孩子作为当前节点，然后在对其进行同样的处理
     * 若其左孩子为空，则输出栈顶点元素并进行出栈操作，访问该栈顶的节点的右孩子
     * 直到p为null并且栈为空则遍历结束
     */
    public static void InOrder2_1(BinTree t){
        Stack<BinTree> s = new Stack<BinTree>();
        while(t != null || !s.empty()){
            while(t !=null){           //和前序的非递归有点像
                s.push(t);
                t = t.lchild;           //一路指向左孩子
            }
            if(! s.empty()){
                t = s.pop();              //取栈顶元素并输出，并指向右孩子
                System.out.print(t.date);
                t = t.rchild;
            }
        }
        System.out.println();
    }

    /*后序非递归实现  这个有难度  因为要保证左孩子和右孩子都已经被访问过了才访问根节点
     * 对于任一节点p,先入栈，然后沿着其左子树往下收索，直到没有左子树的节点，此时该节点入栈
     * 但此时不能进行出栈访问，要检查右孩子，所以接下来一相同的规则进行处理，当访问其右孩子时，
     * 该节点又出现在栈顶，此时就可以出栈访问，这样就保证了正确的访问顺序，这个过程中，
     * 每个节点都两次出现在栈顶，只有在第二次出现在栈顶的时候才能访问它， 因此有必要设置两个栈
     */
    public static void PostOrder3_1(BinTree t){
        Stack<BinTree> s = new Stack<BinTree>();
        Stack<Integer> s2 = new Stack<Integer>();   
        Integer i = new Integer(1);        //第二个栈有0 1 俩元素，1表示第二次访问，0,表示第一次访问
        while(t!=null || !s.empty()){
            while(t!=null){               //压入左孩子
                s.push(t);                  
                s2.push(new Integer(0));
                t = t.lchild;
            }
            //peek查看堆栈顶部的对象，但不从堆栈中移除它。
            while(!s.empty() && s2.peek().equals(i)){  //有两次访问的记录了，就出栈且输出啦，俩栈是同步pop的
                s2.pop();
                System.out.print(s.pop().date);
            }
            if(!s.empty()){         //第二次访问了，栈2的元素置为1，这回要指向右孩子
                s2.pop();
                s2.push(new Integer(1));
                t = s.peek();
                t = t.rchild;
            }
        }
    }
    /*
     * 先扫描跟节点的所有左节点并入栈，接着将栈顶元素出栈，
     * 再扫描该节点的右孩子节点并入栈，扫描右孩子的所有左节点并入栈，当一个节点的左右孩子均被访问后在访问该节点，
     * 这里用一个初始值为null的节点表示右子树刚刚被访问的
     * 一直到栈为空，这里的难点是如何判断右孩子已经被访问过了
     * 个人觉得这个构造真的是太赞了！！
     */
    public static void PostOrder3_2(BinTree t){
        BinTree q = null;
        Stack<BinTree> stack = new Stack<BinTree>();
        while(t!=null)
        {    
            while(t.lchild!=null)            //先左子树入栈,注意:这里最左节点（叶子）没有入栈，后面才入栈
            {
                stack.push(t);
                t = t.lchild;
            }
            while(t.rchild==null || t.rchild ==q )
            {            
                System.out.print(t.date);   //当前节点无右孩子或者右孩子已经输出
                q = t;                      //用来记录上一个节点
                if(stack.empty())
                    return ;               //栈为空时，就结束程序
                t = stack.pop();           //节点出栈
            }        
            stack.push(t);       //！奇葩 1、叶子节点入栈，指向的r.child是null 2、不满足while条件时，处理右孩子
            t = t.rchild;
        }
    }
    
    public static void PostOrder3_3(BinTree t){
        BinTree node = t, prev = t;
        Stack<BinTree> stack = new Stack<BinTree>();
        while(node != null || stack.size()>0)
        {
            while(node!=null)               //压入左孩子
            {
                stack.push(node);
                node = node.lchild;
            }
            if(!stack.empty())
            {
                BinTree temp = stack.peek().rchild;  //记录当前节点的右孩子
                if((temp == null)||temp == prev)
                {
                    node = stack.pop();           //满足俩条件就出栈输出
                    System.out.print(node.date);
                    prev = node;               //标记已经被访问
                    node = null;               //把这个没用的节点置为null.，防止执行上面的while循环
                } 
                else{
                    node = temp;
                }
            }        
        }
    }
    //栈是用数组实现的后序非递归算法，数组里含有所有的元素
    public static void  PostOrder3_4(BinTree t)
    {
            BinTree st[] = new BinTree[1000];        //用数组实现顺序栈    
            int flag,top=-1;                         //栈指针初始化
            BinTree p =t,q;
            do
            {
                while(p!=null)                  //将p的所有左节点入栈
                {
                    top++;
                    st[top] = p;
                    p = p.lchild;
                } 
                q = null;                       //q指向栈顶节点的前一个已经访问的节点
                flag = 1;                       //设置flag = 1表示处理栈顶节点            
                while(top !=-1 && flag ==1)
                {
                    p = st[top];                //取出栈顶的元素
                    if(p.rchild==q)             //右孩子不存在或者右孩子已经被访问，访问之
                    {
                        System.out.print(p.date);
                        top--;
                        q=p;                    //q指向刚刚被访问的节点
                    }
                    else
                    {    
                        p = p.rchild;           //p指向右孩子节点
                        flag =0;                //flag=0表示栈顶节点处理完毕
                    }                        
                }            
        }while(top!=-1);                       //栈不为空时循环
        System.out.println(); 
    }        
    
    /*广度优先遍历树,又叫层次遍历
     * 1.首先将根节点放入队列中。
       2.当队列为非空时，循环执行步骤3到步骤5，否则执行6；
       3.出队列取得一个结点，访问该结点；
       4.若该结点的左子树为非空，则将该结点的左子树入队列；
       5.若该结点的右子树为非空，则将该结点的右子树入队列；
       6.结束。
     */
    /*
     * 补充：队列是什么，提到队列，就要想到先进先进先出，即为先进先出队列，先进来的人先服务，我们日常生活
     * 排队时不是先到的人先接受服务么？
     */
    public static void BFSOrder(BinTree t)
    {
        if(t==null) return ;
        Queue<BinTree> queue = new ArrayDeque<BinTree>();    
        //队列小知识：使用offer和poll优于add和remove之处在于它们返回值可以判断成功与否，而不抛出异常
        queue.offer(t);              //进入队列
        while(!queue.isEmpty())
        {
            t=queue.poll();           //当前节点出队列
            System.out.print(t.date);
            if(t.lchild!=null)              //当前节点左孩子去排队，在前面哦
                queue.offer(t.lchild);
            if(t.rchild!=null)            //右孩子排第二
                queue.offer(t.rchild);    
        }
    }
    public static void main(String[] args) {
         BinTree b1 = new BinTree('a');
         BinTree b2 = new BinTree('b');
         BinTree b3 = new BinTree('c');
         BinTree b4 = new BinTree('d');
         BinTree b5 = new BinTree('e');
         BinTree b6 = new BinTree('f');
         BinTree b7 = new BinTree('g');
    
        /**
         *      a 
         *    /   
         *   b     c
         *  /    / 
         * d   e f   g
         */
        b1.lchild = b2;
        b1.rchild = b3;
        b2.lchild = b4;
        b2.rchild = b5;
        b3.lchild = b6;
        b3.rchild = b7;
    
        BinTree.preOrder1(b1);
        System.out.println();
        
        BinTree.preOrder1_1(b1);
        System.out.println();
        
        BinTree.InOrder2(b1);
        System.out.println();
        BinTree.InOrder2_1(b1);
        System.out.println();
        
        BinTree.PostOrder3(b1);
        System.out.println();

        BinTree.PostOrder3_1(b1);    
        System.out.println();
        BinTree.PostOrder3_2(b1);
        System.out.println();
        BinTree.PostOrder3_3(b1);
        System.out.println();
        BinTree.PostOrder3_4(b1);
        System.out.println();
        
        BinTree.BFSOrder(b1);
        System.out.println();    
        }
}

网上有好的很好的文章都有写道这几个搜索算法，这个博客是用c++实现的

http://www.blogjava.net/fancydeepin/archive/2013/02/03/cpp_binarytreesearch.html