java实现二叉查找树

1.什么是二叉查找树

               二叉查找树是应用了链表的灵活性和数组的查找的高效性来实现对数据的操作和查找。

               二叉查找树要么是一棵空树，要么就必须具有如下特征:

                         1.二叉查找树只能有左右两棵子树

                         2.根节点的值大于左子树的值，小于右子树的值（左右子树不为空的情况）

                         3.每个节点都有相应的键和值，且不存在键值相同的点

2.二叉查找树的作用

               对数据进行排序以实现对数据的高效查找。

3.二叉查找树与二分法的区别

               二叉查找树是基于节点的，通过链表结构实现的，而二分法是通过数组实现的，所以当

          插入数据或者删除数据的时候，二叉查找树不需要移动后面的那些节点数据，只需要改变节

          点的所指的方向就可以了，而二分法是数组实现的，插入和删除数据需要将后面的数据移动

          一位，因此二叉查找树比二分法更加高效。

4.二叉查找树的实现

1. import java.util.Iterator;
2. 
   
3. /**
4.  * 二叉查找树
5.  * @author spenglu
6.  *
7.  */
8. public class BinarySearchTree<Key extends Comparable<Key>,Value> {
9.     private Node root;
10.     private class Node{
11.          private Key key;
12.          private Value value;
13.          private Node left;
14.          private Node right;
15.          private int n;  //以该节点为根的子数中的节点总数
16. 
    
17.          public Node(Key key,Value value,int n){
18.              this.key = key;
19.              this.value = value;
20.              this.n = n;
21.          }
22.     }
23.     //节点总数
24.     public int size(){
25.          return size(root);
26.     }
27. 
    
28.     private int size(Node root2) {
29.          // TODO Auto-generated method stub
30.          if (root2==null) return 0;
31.          return root2.n;
32.     }
33. 
    
34.     //通过键获取相应的值
35.     public Value get(Key key){
36.          return get(root,key);
37.     }
38. 
    
39.     private Value get (Node root2, Key key) {
40.          // TODO Auto-generated method stub
41.          if (root2==null) return null;
42.          int cmp = key.compareTo(root2.key);
43.          if (cmp<0) return get(root2.left, key);
44.          if (cmp>0) return get(root.right, key);
45.          else return root2.value;
46.     }
47. 
    
48.     //插入相应的键值对
49.     //如果是已存在这个节点则更新这个节点，否则插入这个新节点
50.     //实际就是构建二叉查找树的方法
51.     public void put (Key key,Value value) {
52.          root = put(root, key,value);
53.     }
54. 
    
55.     private Node put(Node root2, Key key, Value value) {
56.          // TODO Auto-generated method stub
57.          if(root2==null) return new Node(key, value, 1);
58.          int cmp = key.compareTo(root2.key);
59.          if(cmp<0) root2.left = put(root2.left, key, value);
60.          if(cmp>0) root2.right = put(root2.right, key, value);
61.          else root2.value=value;
62.          root2.n = size(root2.left)+size(root2.right)+1;
63.          return root2;
64.     }
65. 
    
66.     //获取值最大的键
67.     public Key max(){
68.          return max(root).key;
69.     }
70. 
    
71.     private Node max(Node root2) {
72.          // TODO Auto-generated method stub
73.          if(root2==null) return root2;
74.          return max(root2.right);
75.     }
76. 
    
77.     //获取值最小的键
78.     public Key min(){
79.          return min(root).key;
80.     }
81. 
    
82.     private Node min(Node root2) {
83.          // TODO Auto-generated method stub
84.          if(root2==null) return root2;
85.          return min(root2.left);
86.     }
87. 
    
88.     //向下取整,获取小于等于某个值的键
89.     public Key floor(Key key){
90.          Node x = floor(root,key);
91.          if(x==null) return null;
92.          return x.key;
93.     }
94. 
    
95.     private Node floor(Node root2, Key key) {
96.          // TODO Auto-generated method stub
97.          if(root2==null) return null;
98.          int cmp = key.compareTo(root2.key);
99.          if(cmp==0) return root2;
100.          if(cmp<0) return floor(root.left, key);
101.          Node x = floor(root2.right, key);
102.          if(x!=null) return x;
103.          else return root2;
104.     }
105. 
     
106.     //向上去整，获取大于等于某个值的键
107.     public Key ceiling(Key key){
108.          Node x = ceiling(root,key);
109.          if(x==null) return null;
110.          return x.key;
111.     }
112. 
     
113.     private Node ceiling(Node root2, Key key) {
114.          // TODO Auto-generated method stub
115.          if(root2==null) return null;
116.          int cmp = key.compareTo(root2.key);
117.          if(cmp==0) return root2;
118.          if(cmp>0) return ceiling(root2.right, key);
119.          Node x = ceiling(root2.left, key);
120.          if(x!=null) return x;
121.          else return root2;
122.     }
123. 
     
124.     //找到排名为k的键
125.     public Key select(int k){
126.          return select(root,k).key;
127.     }
128. 
     
129.     private Node select(Node root2, int k) {
130.          // TODO Auto-generated method stub
131.          if(root2==null) return null;
132.          int temp = size(root2);
133.          if(k>temp) return select(root2.right, k-temp-1);
134.          else if(k<temp) return select(root2.left, k);
135.          else return root2;
136.     }
137. 
     
138.     //返回给定键的排名
139.     public int rank(Key key){
140.          return rank(root,key);
141.     }
142. 
     
143.     private int rank(Node root2, Key key) {
144.          // TODO Auto-generated method stub
145.          if(root2==null) return 0;
146.          int cmp = key.compareTo(root2.key);
147.          if(cmp<0) return rank(root2.left, key);
148.          else if(cmp>0) return size(root2.left)+1+rank(root2.right,key);
149.          else return size(root2.left);
150.     }
151. 
     
152.     //删除最小值
153.     public void deleteMin(){
154.          root = deleteMin(root);
155.     }
156. 
     
157.     private Node deleteMin(Node root2) {
158.          // TODO Auto-generated method stub
159.          if(root2.left==null) return root2.right;
160.          root2.left = deleteMin(root2.left);
161.          root2.n = size(root2.left)+size(root2.right)+1;
162.          return root2;
163.     }
164. 
     
165.     //删除最大值
166.     public void deleteMax(){
167.          root = deleteMax(root);
168.     }
169. 
     
170.     private Node deleteMax(Node root2) {
171.          // TODO Auto-generated method stub
172.          if(root2.right==null) return root2.left;
173.          root2.right = deleteMax(root2.right);
174.          root2.n = size(root2.left)+size(root2.right)+1;
175.          return root2;
176.     }
177. 
     
178.     //删除给定某个给定键的值
179.     public void delete(Key key){
180.          root = delete(root,key);
181.     }
182. 
     
183.     private Node delete(Node root2, Key key) {
184.          // TODO Auto-generated method stub
185.          if(root2==null) return null;
186.          int cmp = key.compareTo(root2.key);
187.          if(cmp<0) root2.left = delete(root2.left, key);
188.          else if(cmp>0) root2.right = delete(root2.right, key);
189.          else{
190.              if(root2.right==null) return root2.left;
191.              if(root2.left==null) return root2.right;
192.              Node x = root2;
193.              root2 = min(x.right);
194.              root2.right = deleteMin(x.right);
195.              root2.left = x.left;
196.          }
197.          root2.n = size(root2.left)+size(root2.right)+1;
198.          return root2;
199.     }
200. 
     
201.     //二叉查找树的构建
202.     public void buildTree(Key key,Value value){
203.          root = buildTree(root, key,value);
204.     }
205. 
     
206.     private Node buildTree(Node root2, Key key, Value value) {
207.          // TODO Auto-generated method stub
208.          if (root2==null) return new Node(key, value, 1);
209.          int cmp = key.compareTo(root2.key);
210.          if (cmp<0) root2.left = buildTree(root2.left, key, value);
211.          else if (cmp>0) root2.right = buildTree(root2.right, key, value);
212.          else root2.value=value;
213.          root2.n = size(root2.left)+size(root2.right)+1;
214.          return root2;
215.     }
216. 
     
217.     public static void main(String[] args) {
218. 
     
219.     }
220. }