java实现二叉树的三种遍历算法(递归)

一，定义一个节点类

1. package test;  
2.   
3. public class Node {  
4.     private int data;  
5.     private Node left;  
6.     private Node right;  
7.     public Node(int data) {  
8.         this.data = data;  
9.     }  
10.     public int getData() {  
11.         return data;  
12.     }  
13.     public void setData(int data) {  
14.         this.data = data;  
15.     }  
16.     public Node getLeft() {  
17.         return left;  
18.     }  
19.     public void setLeft(Node left) {  
20.         this.left = left;  
21.     }  
22.     public Node getRight() {  
23.         return right;  
24.     }  
25.     public void setRight(Node right) {  
26.         this.right = right;  
27.     }  
28.       
29. }  

二，定义一个算法实现类：

[java]  view plain  copy

1. package test;  
2.   
3. public class FindTree {  
4.   
5.     private void visit(int data) {  
6.         System.out.print(data+"--");  
7.     }  
8.       
9.     public void preOrder(Node root) {  
10.         if(root == null) {  
11.             return;  
12.         }  
13.         visit(root.getData());  
14.         preOrder(root.getLeft());  
15.         preOrder(root.getRight());  
16.     }  
17.       
18.     public void inOrder(Node root) {  
19.         if(root == null) {  
20.             return;  
21.         }  
22.         inOrder(root.getLeft());  
23.         visit(root.getData());  
24.         inOrder(root.getRight());  
25.     }  
26.       
27.     public void afterOrder(Node root) {  
28.         if(root == null) {  
29.             return;  
30.         }  
31.         afterOrder(root.getLeft());  
32.         afterOrder(root.getRight());  
33.         visit(root.getData());  
34.     }  
35.       
36. }  

三，构建一个二叉树

[java]  view plain  copy

1. package test;  
2.   
3.   
4. public class TestTree {  
5.   
6.     public static void main(String[] args) {  
7.         FindTree ft = new FindTree();  
8.         int[] array = {12,76,35,22,16,48,90,46,9,40};  
9.         int j = 0;  
10.         Node root = new Node(array[j]);  
11.         for(int i = 1; i< array.length; i++) {  
12.             insert(root, array[i]);  
13.         }  
14.         System.out.println("preorder----------------------------------");  
15.         ft.preOrder(root);  
16.         System.out.println("  
17. inorder----------------------------------");  
18.         ft.inOrder(root);  
19.         System.out.println("  
20. afterorder----------------------------------");  
21.         ft.afterOrder(root);  
22.           
23.     }  
24.   
25.     private static void insert(Node root, int data) {  
26.           //二叉树中左边的孩子节点小于父节点，右边的孩子节点大于父节点  
27.         if(root.getData() < data) {  
28.             if(root.getRight() == null) {  
29.                 root.setRight(new Node(data));  
30.             } else {  
31.                 insert(root.getRight(), data);  
32.             }  
33.         } else {  
34.             if(root.getLeft() == null) {  
35.                 root.setLeft(new Node(data));  
36.             } else {  
37.                 insert(root.getLeft(), data);  
38.             }  
39.         }  
40.     }   
41. }  

四，打印结果：

preorder----------------------------------

12--9--76--35--22--16--48--46--40--90--

inorder----------------------------------

9--12--16--22--35--40--46--48--76--90--

afterorder----------------------------------

9--16--22--40--46--48--35--90--76--12--