数据结构之关于树的操作(树的递归和非递归遍历)

前面写了一些关于树的操作，但是没有实现树的遍历的非递归写法。

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

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

  树的结构如下：

                      

  层次遍历：123456789

  前序遍历：124895367

  中序遍历：849251637

  后序遍历：894526731

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

    

[java] view plaincopyprint?

1. package com.lip.datastructure.tree;  
2.   
3. import java.util.Stack;  
4. /** 
5.  * @author lip 
6.  */  
7. public class Tree  
8.     {  
9.         public static void main(String[] args)  
10.             {  
11.                Node<Integer>root=getNode();  
12.                System.out.println("前序遍历（非递归）");  
13.                preOrder(root);  
14.                System.out.println("前序遍历（递归）");  
15.                preOrderRecursive(root);  
16.                System.out.println();  
17.                System.out.println("中序遍历（非递归）");  
18.                infixOrder(root);  
19.                System.out.println("中序遍历（递归）");  
20.                infixOrderRecursive(root);  
21.                System.out.println();  
22.                System.out.println("后序遍历（非递归）");  
23.                postOrder(root);  
24.                System.out.println("后序遍历（递归）");  
25.                postOrderRecursive(root);  
26.   
27.             }  
28.         public static Node getNode()  
29.         {  
30.             Node<Integer>node1=new Node(1);  
31.             Node<Integer>node2=new Node(2);  
32.             Node<Integer>node3=new Node(3);  
33.             node1.left=node2;  
34.             node1.right=node3;  
35.             Node<Integer>node4=new Node(4);  
36.             Node<Integer>node5=new Node(5);  
37.             node2.left=node4;  
38.             node2.right=node5;  
39.             Node<Integer>node6=new Node(6);  
40.             Node<Integer>node7=new Node(7);  
41.             node3.left=node6;  
42.             node3.right=node7;  
43.             Node<Integer>node8=new Node(8);  
44.             Node<Integer>node9=new Node(9);  
45.             node4.left=node8;  
46.             node4.right=node9;  
47.             return node1;  
48.         }  
49.         //前序遍历，非递归  
50.         @SuppressWarnings("rawtypes")  
51.         public static void preOrder(Node root)  
52.         {  
53.             Stack<Node>stack=new Stack<Node>();  
54.             stack.push(root);  
55.             while(stack.size()>0)  
56.                 {  
57.                     Node tempNode=stack.pop();  
58.                     if(tempNode!=null)  
59.                         {  
60.                           System.out.print(tempNode.data);  
61.                           stack.push(tempNode.right);  
62.                           stack.push(tempNode.left);  
63.                         }  
64.                 }  
65.             System.out.println();  
66.         }  
67.         //前序遍历(根左右)，递归  
68.         public static void preOrderRecursive(Node root)  
69.         {  
70.             if(root!=null)  
71.                 {  
72.                     System.out.print(root.data);  
73.                     preOrderRecursive(root.left);  
74.                     preOrderRecursive(root.right);  
75.                 }  
76.         }  
77.         //中序遍历（左根右），非递归  
78.         public static void infixOrder(Node root)  
79.         {  
80.             Stack<Node>stack=new Stack<Node>();  
81.             stack.push(root);  
82.             while(stack.size()>0)  
83.                 {  
84.                     Node temp=stack.pop();  
85.                     if(temp!=null)  
86.                         {  
87.                             if((temp.left==null)&&(temp.right==null))  
88.                                 System.out.print(temp.data);  
89.                             else  
90.                                 {  
91.                                     stack.push(temp.right);  
92.                                     stack.push(new Node(temp.data));  
93.                                     stack.push(temp.left);  
94.                                 }  
95.                         }  
96.                 }  
97.             System.out.println();  
98.         }  
99.         //中序遍历（左根右），递归  
100.         public static void infixOrderRecursive(Node root)  
101.         {  
102.             if(root!=null)  
103.                 {  
104.                     infixOrderRecursive(root.left);  
105.                     System.out.print(root.data);  
106.                     infixOrderRecursive(root.right);  
107.                 }  
108.         }  
109.         //后序遍历（左右根），非递归  
110.         public static void postOrder(Node root)  
111.         {  
112.             Stack<Node>stack=new Stack<Node>();  
113.             stack.push(root);  
114.             Node temp;  
115.             while(stack.size()>0)  
116.                 {  
117.                     temp=stack.pop();  
118.                     if(temp!=null)  
119.                         {  
120.                             if(temp.left==null&&temp.right==null)  
121.                                 System.out.print(temp.data);  
122.                             else {  
123.                                 stack.push(new Node(temp.data));  
124.                                 stack.push(temp.right);  
125.                                 stack.push(temp.left);  
126.                             }  
127.                         }  
128.                 }  
129.             System.out.println();  
130.         }  
131.         //后序遍历（左右根），递归  
132.         public static void postOrderRecursive(Node root)  
133.         {  
134.             if(root!=null)  
135.                 {  
136.                     postOrderRecursive(root.left);  
137.                     postOrderRecursive(root.right);  
138.                     System.out.print(root.data);  
139.                 }  
140.         }  
141.   
142.   
143.     }  
144.    class Node <T>  
145.    {  
146.        public Node left;  
147.        public Node right;  
148.        public T data;  
149.        public Node(T data)  
150.        {  
151.            this.data=data;  
152.        }  
153.    }  

<span style="font-family:KaiTi_GB2312;font-size:12px;">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;   }   }</span>

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