二叉树实现学习

1. package com.javaeye.rsrt;   
2.   
3. /**  
4.  *   
5.  * @author nishiting  
6.  *  
7.  */  
8.   
9. public class BinaryTree {   
10.   
11.     private Node root;   
12.        
13.     /**  
14.      * 内部类实现结点类，可提高安全性  
15.      * @author nishiting  
16.      *  
17.      */  
18.   
19.     private static class Node {   
20.         Node left;   
21.         Node right;   
22.         int data;   
23.   
24.         Node(int newData) {   
25.             left = null;   
26.             right = null;   
27.             data = newData;   
28.         }   
29.   
30.     }   
31.   
32.     /**  
33.      * 创建一个空的二叉树  
34.      */  
35.   
36.     public BinaryTree() {   
37.         root = null;   
38.     }   
39.        
40.     /**  
41.      * 递归的插入数值  
42.      * @param data  要插入的数值  
43.      */  
44.   
45.     public void insert(int data) {   
46.         root = insert(root, data);   
47.     }   
48.        
49.     /**  
50.      * 将数值插入到二叉树中，比当前结点小或等于当前结点的插在当前结点的左侧，比当前结点大的数插在当前结点的右侧，每次从根结点开始递归比较  
51.      * @param node  当前的结点，就是根结点，只是每次根结点的左右子孙更新  
52.      * @param data  要插入的数值  
53.      * @return  新排好的二叉树  
54.      */  
55.   
56.     private Node insert(Node node, int data) {   
57.   
58.         if (node == null) {   
59.   
60.             node = new Node(data);   
61.   
62.         } else {   
63.             if (data <= node.data) {   
64.                 node.left = insert(node.left, data);   
65.             } else {   
66.                 node.right = insert(node.right, data);   
67.             }   
68.         }   
69.         return (node);   
70.     }   
71.        
72.     /**  
73.      * 将数值输入构建二叉树  
74.      * @param data  要输入的数值  
75.      */  
76.   
77.     public void buildTree(int[] data) {   
78.   
79.         for (int i = 0; i < data.length; i++) {   
80.   
81.             insert(data[i]);   
82.   
83.         }   
84.   
85.     }   
86.        
87.     /**  
88.      * 递归打印出二叉树  
89.      */  
90.   
91.     public void printTree() {   
92.   
93.         printTree(root);   
94.   
95.         System.out.println();   
96.   
97.     }   
98.        
99.     /**  
100.      * 从根结点开始遍历，从树的最高层叶子结点开始输出，从左至右  
101.      * @param node  当前的结点  
102.      */  
103.   
104.     private void printTree(Node node) {   
105.   
106.         if (node == null)   
107.             return;   
108.   
109.         // left, node itself, right   
110.   
111.         printTree(node.left);   
112.   
113.         System.out.print(node.data + "  ");   
114.   
115.         printTree(node.right);   
116.   
117.     }   
118.   
119. }  

package com.javaeye.rsrt;

/**
 * 
 * @author nishiting
 *
 */

public class BinaryTree {

	private Node root;
	
	/**
	 * 内部类实现结点类，可提高安全性
	 * @author nishiting
	 *
	 */

	private static class Node {
		Node left;
		Node right;
		int data;

		Node(int newData) {
			left = null;
			right = null;
			data = newData;
		}

	}

	/**
	 * 创建一个空的二叉树
	 */

	public BinaryTree() {
		root = null;
	}
	
	/**
	 * 递归的插入数值
	 * @param data	要插入的数值
	 */

	public void insert(int data) {
		root = insert(root, data);
	}
	
	/**
	 * 将数值插入到二叉树中，比当前结点小或等于当前结点的插在当前结点的左侧，比当前结点大的数插在当前结点的右侧，每次从根结点开始递归比较
	 * @param node	当前的结点，就是根结点，只是每次根结点的左右子孙更新
	 * @param data	要插入的数值
	 * @return	新排好的二叉树
	 */

	private Node insert(Node node, int data) {

		if (node == null) {

			node = new Node(data);

		} else {
			if (data <= node.data) {
				node.left = insert(node.left, data);
			} else {
				node.right = insert(node.right, data);
			}
		}
		return (node);
	}
	
	/**
	 * 将数值输入构建二叉树
	 * @param data	要输入的数值
	 */

	public void buildTree(int[] data) {

		for (int i = 0; i < data.length; i++) {

			insert(data[i]);

		}

	}
	
	/**
	 * 递归打印出二叉树
	 */

	public void printTree() {

		printTree(root);

		System.out.println();

	}
	
	/**
	 * 从根结点开始遍历，从树的最高层叶子结点开始输出，从左至右
	 * @param node	当前的结点
	 */

	private void printTree(Node node) {

		if (node == null)
			return;

		// left, node itself, right

		printTree(node.left);

		System.out.print(node.data + "  ");

		printTree(node.right);

	}

}

 测试类：

Java代码

1. package com.javaeye.rsrt;   
2.   
3. import junit.framework.TestCase;   
4.   
5. public class BinaryTreeTest extends TestCase {   
6.   
7.     public void testBinaryTreeTest() {   
8.   
9.         BinaryTree biTree = new BinaryTree();   
10.   
11.         int[] data = { 2, 8, 7, 4 ,9,3,1,6,7,5};   
12.   
13.         biTree.buildTree(data);   
14.   
15.         biTree.printTree();   
16.   
17.     }   
18.   
19. }