数据结构之关于树的操作(树的递归和非递归遍历)-（四补）

通常树有四种遍历方法：1.层次遍历（需要用到树的高度，此文没有考虑）

                 2.前序遍历(根左右)；3.中序遍历(左根右)；4.后序遍历(左右根)

  树的结构如下：

                      

  层次遍历：123456789

  前序遍历：124895367

  中序遍历：849251637

  后序遍历：894526731

    java代码实现三种遍历的递归和和非递归实现 

    package com.lip.datastructure.tree;  
      
    import java.util.Stack;  
    /** 
     * @author lip 
     */  
    public class Tree  
        {  
            public static void main(String[] args)  
                {  
                   Node<Integer>root=getNode();  
                   System.out.println("前序遍历（非递归）");  
                   preOrder(root);  
                   System.out.println("前序遍历（递归）");  
                   preOrderRecursive(root);  
                   System.out.println();  
                   System.out.println("中序遍历（非递归）");  
                   infixOrder(root);  
                   System.out.println("中序遍历（递归）");  
                   infixOrderRecursive(root);  
                   System.out.println();  
                   System.out.println("后序遍历（非递归）");  
                   postOrder(root);  
                   System.out.println("后序遍历（递归）");  
                   postOrderRecursive(root);  
      
                }  
            public static Node getNode()  
            {  
                Node<Integer>node1=new Node(1);  
                Node<Integer>node2=new Node(2);  
                Node<Integer>node3=new Node(3);  
                node1.left=node2;  
                node1.right=node3;  
                Node<Integer>node4=new Node(4);  
                Node<Integer>node5=new Node(5);  
                node2.left=node4;  
                node2.right=node5;  
                Node<Integer>node6=new Node(6);  
                Node<Integer>node7=new Node(7);  
                node3.left=node6;  
                node3.right=node7;  
                Node<Integer>node8=new Node(8);  
                Node<Integer>node9=new Node(9);  
                node4.left=node8;  
                node4.right=node9;  
                return node1;  
            }  
            //前序遍历，非递归  
            @SuppressWarnings("rawtypes")  
            public static void preOrder(Node root)  
            {  
                Stack<Node>stack=new Stack<Node>();  
                stack.push(root);  
                while(stack.size()>0)  
                    {  
                        Node tempNode=stack.pop();  
                        if(tempNode!=null)  
                            {  
                              System.out.print(tempNode.data);  
                              stack.push(tempNode.right);  
                              stack.push(tempNode.left);  
                            }  
                    }  
                System.out.println();  
            }  
            //前序遍历(根左右)，递归  
            public static void preOrderRecursive(Node root)  
            {  
                if(root!=null)  
                    {  
                        System.out.print(root.data);  
                        preOrderRecursive(root.left);  
                        preOrderRecursive(root.right);  
                    }  
            }  
            //中序遍历（左根右），非递归  
            public static void infixOrder(Node root)  
            {  
                Stack<Node>stack=new Stack<Node>();  
                stack.push(root);  
                while(stack.size()>0)  
                    {  
                        Node temp=stack.pop();  
                        if(temp!=null)  
                            {  
                                if((temp.left==null)&&(temp.right==null))  
                                    System.out.print(temp.data);  
                                else  
                                    {  
                                        stack.push(temp.right);  
                                        stack.push(new Node(temp.data));  
                                        stack.push(temp.left);  
                                    }  
                            }  
                    }  
                System.out.println();  
            }  
            //中序遍历（左根右），递归  
            public static void infixOrderRecursive(Node root)  
            {  
                if(root!=null)  
                    {  
                        infixOrderRecursive(root.left);  
                        System.out.print(root.data);  
                        infixOrderRecursive(root.right);  
                    }  
            }  
            //后序遍历（左右根），非递归  
            public static void postOrder(Node root)  
            {  
                Stack<Node>stack=new Stack<Node>();  
                stack.push(root);  
                Node temp;  
                while(stack.size()>0)  
                    {  
                        temp=stack.pop();  
                        if(temp!=null)  
                            {  
                                if(temp.left==null&&temp.right==null)  
                                    System.out.print(temp.data);  
                                else {  
                                    stack.push(new Node(temp.data));  
                                    stack.push(temp.right);  
                                    stack.push(temp.left);  
                                }  
                            }  
                    }  
                System.out.println();  
            }  
            //后序遍历（左右根），递归  
            public static void postOrderRecursive(Node root)  
            {  
                if(root!=null)  
                    {  
                        postOrderRecursive(root.left);  
                        postOrderRecursive(root.right);  
                        System.out.print(root.data);  
                    }  
            }  
      
      
        }  
       class Node <T>  
       {  
           public Node left;  
           public Node right;  
           public T data;  
           public Node(T data)  
           {  
               this.data=data;  
           }  
       }  

其实递归和非递归的区别也就是非递归使用stack来回溯（也可以看做是一种特殊的递归）