二叉树的遍历Java实现_world

1. import java.util.ArrayList;  
2. import java.util.LinkedList;  
3. import java.util.List;  
4.   
5. public class LevelTraverseBinaryTree {  
6.   
7.     /** 
8.      * 编程之美 分层遍历二叉树 
9.      * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要标记什么时候要换行： 
10.      * 用inCount记录某层有多少个元素，outCount记录当前输出了多少个元素；当inCount==outCount时，就说明某层元素已经完全输出，此时应该换行(outCount清零) 
11.      * 此外，观察发现，当第K层元素全部出队（并已将各自左右孩子入队）后，队列里面刚好存放了第K+1层的所有元素，不多不少，所以有：inCount = queue.size(); 
12.      *  
13.      * 书上的扩展问题也很有意思（从下往上分层输出），既然是反过来输出，第一反应是利用栈 
14.      * 但同时又要记录何时换行（每行有多少个元素），只好用ArrayList模拟一个“伪栈”： 
15.      * 1、第一步操作和“从上往下分层输出”是类似的：从root开始遍历，并将所有元素放入“队列”（ArrayList），用-1表示一层的结束 
16.      * 2、输出。不是从队头开始，而是从队尾开始，依次输出 
17.      * 分析到这里，这里面的ArrayList定义为“双向队列”更合适 
18.      */  
19.     public static void main(String[] args) {  
20.         /* 
21.                             __1__ 
22.                            /     \ 
23.                         __2__     3__ 
24.                        /     \       \ 
25.                       4     __5__     6 
26.                            7     8 
27.          */  
28.         int[] src = { 1, 2, 3, 4, 5, 0, 6, 0, 0, 7, 8 };  
29.         LevelTraverseBinaryTree data = new LevelTraverseBinaryTree();  
30.         Node root = data.createTree(src);  
31.         data.traverseByLevelFromTop(root);  
32.         System.out.println();  
33.         data.traverseByLevelFromBottom(root);  
34.     }  
35.       
36.     /* 
37.      从上往下分层输出 
38.         1  
39.         2 3  
40.         4 5 6  
41.         7 8  
42.      */  
43.     public void traverseByLevelFromTop(Node node) {  
44.         if (node == null) {  
45.             return;  
46.         }  
47.         LinkedList<Node> queue = new LinkedList<Node>();  
48.         queue.addLast(node);  
49.         int inCount = 1;  
50.         int outCount = 0;  
51.         while (!queue.isEmpty()) {  
52.             Node curNode = queue.pollFirst();  
53.             System.out.print(curNode.getData() + " ");  
54.             outCount++;  
55.             if (curNode.getLeft() != null) {  
56.                 queue.addLast(curNode.getLeft());  
57.             }  
58.             if (curNode.getRight() != null) {  
59.                 queue.addLast(curNode.getRight());  
60.             }  
61.             if (outCount == inCount) {  
62.                 System.out.println();  
63.                 inCount = queue.size();  
64.                 outCount = 0;  
65.             }  
66.         }  
67.     }  
68.       
69.     /* 
70.     从下往上分层输出 
71.         7 8  
72.         4 5 6  
73.         2 3  
74.         1  
75.     */  
76.     public void traverseByLevelFromBottom(Node node) {  
77.         if (node == null) {  
78.             return;  
79.         }  
80.         List<Node> list = new ArrayList<Node>();  
81.         list.add(node);  
82.         list.add(new Node(-1));     //-1表示一层结束，打印时要换行  
83.         int i = 0;  
84.         int size = list.size();  
85.         while (i < size) {  
86.             Node curNode = list.get(i);  
87.               
88.             /*交换下面这两个操作，可实现输出： 
89.                 8 7  
90.                 6 5 4  
91.                 3 2  
92.                 1 
93.              */  
94.             if (curNode.getRight() != null) {  
95.                 list.add(curNode.getRight());  
96.             }   
97.             if (curNode.getLeft() != null) {  
98.                 list.add(curNode.getLeft());  
99.             }  
100.               
101.             i++;  
102.             if (i == size) {  
103.                 if (curNode.getData() != -1 && curNode.getLeft() == null && curNode.getRight() == null) {   //已经遍历到最底层的最后一个元素，结束循环  
104.                     break;  
105.                 }  
106.                 size = list.size();  
107.                 list.add(new Node(-1));       
108.             }  
109.         }  
110.           
111.         //从后往前遍历，相当于“栈”  
112.         for (size = list.size(), i = size - 1; i >=0; i--) {  
113.             int val = list.get(i).getData();  
114.             if (val == -1) {  
115.                 System.out.println();  
116.             } else {  
117.                 System.out.print(val + " ");  
118.             }  
119.         }  
120.     }  
121.       
122.   
123.     public Node createTree(int[] data){    
124.         List<Node> nodeList=new ArrayList<Node>();    
125.         for(int each:data){    
126.             Node n=new Node(each);    
127.             nodeList.add(n);    
128.         }    
129.         int lastRootIndex=data.length/2-1;    
130.         for(int i=0;i<=lastRootIndex;i++){    
131.             Node root=nodeList.get(i);    
132.             Node left=nodeList.get(i*2+1);    
133.             if(left.getData()!=0){    
134.                 root.setLeft(left);    
135.             }else{    
136.                 root.setLeft(null);    
137.             }    
138.             if(i*2+2<data.length){    
139.                 Node right=nodeList.get(i*2+2);    
140.                 if(right.getData()!=0){    
141.                     root.setRight(right);    
142.                 }else{    
143.                     root.setRight(null);    
144.                 }    
145.             }    
146.                 
147.         }    
148.         Node root=nodeList.get(0);    
149.         return root;    
150.     }    
151. }  
152.   
153. class Node {  
154.       
155.     int data;  
156.     Node left;  
157.     Node right;  
158.   
159.     Node(int data) {  
160.         this.data = data;  
161.     }  
162.   
163.     public int getData() {  
164.         return data;  
165.     }  
166.   
167.     public void setData(int data) {  
168.         this.data = data;  
169.     }  
170.   
171.     public Node getLeft() {  
172.         return left;  
173.     }  
174.   
175.     public void setLeft(Node left) {  
176.         this.left = left;  
177.     }  
178.   
179.     public Node getRight() {  
180.         return right;  
181.     }  
182.   
183.     public void setRight(Node right) {  
184.         this.right = right;  
185.     }  
186. }