自己写的java实现的多路搜索树 B-Tree

  1 package com.test1;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStreamReader;
  6 import java.util.ArrayList;
  7 import java.util.List;
  8 import java.util.NoSuchElementException;
  9 
 10 /**
 11  * Created by MSI on 2016/1/5.
 12  *  该程序参考文章：http://blog.csdn.net/v_JULY_v/article/details/6530142/
 13  */
 14 public class BsubTree<T extends Comparable<T>> {
 15 
 16     private static BsubTree<Integer> tree = new BsubTree<Integer>();
 17     private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
 18 
 19     int m = 4;      //此B-树的阶数。关键字数等于阶数-1。m至少为2，m必须大于等于2。
 20     int n;      //n是关键字最小个数
 21     public BTNode root;
 22 
 23     public BsubTree(){
 24         root = new BTNode(null,null);
 25         if(m>=2){
 26             if(m%2==0){
 27                 n = m/2-1;
 28             }else {
 29                 n = m/2;
 30             }
 31         }else {
 32             System.out.println("error");
 33             System.exit(0);
 34         }
 35     }
 36 
 37     public BsubTree(BTNode root){
 38         this.root = root;
 39         if(m%2==0){
 40             n = m/2;
 41         }else {
 42             n = m/2+1;
 43         }
 44     }
 45 
 46     public BTNode findNode(T information){
 47         return findNode(information, root);
 48     }   //isMember应该返回插入点
 49 
 50     private BTNode findNode(T info, BTNode node){   //不论是否找到都返回一个node。
 51         BTNode member = null;
 52 
 53         if(node.informations.size()==0){//这种情况存在,只有root可能
 54             member = node;
 55             //System.out.println("error");
 56         }else {
 57             if(info.compareTo(node.informations.get(node.informations.size()-1))>0) {    //info比节点最大的还大，则直接进入最右分支
 58                     if(node.ptr.size()>0){//有孩子的情况，进入范围中的子节点
 59                         member = findNode(info, node.ptr.get(node.informations.size()));
 60                     }else {//没有子节点，直接返回node
 61                         member = node;
 62                     }
 63             }else {//没有判断没有子节点的情况，上一个if中判断了，这一个else中就忘了，怒
 64                 if(node.ptr.size()>0){//有子节点
 65                     if(info.compareTo(node.informations.get(0))<0){
 66                         member = findNode(info, node.ptr.get(0));
 67                     }else {
 68                         for(int i = 0;i<node.informations.size();++i){
 69                             if(info.compareTo(node.informations.get(i))==0){
 70                                 member = node;
 71                                 break;
 72                             }else if(info.compareTo(node.informations.get(i))>0&&info.compareTo(node.informations.get(i+1))<0){   //只要不是最右，info比之大的，进入它的孩子节点
 73                                 member = findNode(info, node.ptr.get(i+1));
 74                                 break;
 75                             }
 76                         }
 77                     }
 78                 }else {//没有子节点
 79                     member = node;
 80                 }
 81             }
 82         }
 83         return member;
 84     }
 85 
 86     public void insert(T info){
 87         BTNode temp = findNode(info);
 88         if(temp.informations.size()!=0){
 89             for(T i:temp.informations){
 90                 if(i.compareTo(info)==0){
 91                     System.out.println("已存在所插入的值。");
 92                     return;
 93                 }
 94             }
 95         }
 96         insert(info,temp,temp.parent);
 97         return;
 98     }
 99 
100     private void insert(T info,BTNode node,BTNode parent){//插入一定是在叶子节点
101         if(node == null){//insert中的node为空应该只有一种情况，node=root
102             if(parent == null){
103                 root = new BTNode(info,parent);
104             }else {
105                 System.out.println("不应该出现的情况，请检查。");
106                 //node = new BTNode(info,parent);
107             }
108         }else{
109             if(node.informations.size()==0){
110                 //System.out.println("这种情况应该不存在，请检查代码");//现在存在这种情况啦
111                 node.informations.add(info);
112             }else if(node.informations.size()>0 && node.informations.size()<m-1){
113                 if(info.compareTo(node.informations.get(node.informations.size() - 1))>0){//info比node最右边最大的值还大，则直接插入
114                     node.informations.add(info);
115                 }else {
116                     for (int i = 0; i < node.informations.size(); ++i) {
117                         if (info.compareTo(node.informations.get(i)) < 0) {
118                             node.informations.add(i, info);
119                             break;
120                         }
121                     }
122                 }
123             }else if(node.informations.size()==m-1){//需要分裂
124                 if(info.compareTo(node.informations.get(node.informations.size()-1))>0){//info比node最右边最大的值还大，则直接插入
125                     node.informations.add(info);
126                 }else {
127                     for(int i = 0;i<node.informations.size();++i){
128                         if(info.compareTo(node.informations.get(i))<0){
129                             node.informations.add(i,info);
130                             break;
131                         }
132                     }
133                 }
134 
135                 split(node);
136             }else {
137                 System.out.println("node 的size大于等于m-1，不应该出现，请检查代码");
138             }
139         }
140     }
141 
142     public void delete(T info){
143         BTNode temp = findNode(info,root);
144         if(temp.informations.size()==0){
145             System.out.println("根节点为空！");
146             return;
147         }
148         for(T i:temp.informations){
149             if(info.compareTo(i)==0){
150                 delete(info,temp);
151                 break;
152             }else if(temp.informations.indexOf(i)==temp.informations.size()-1){//循环到最后一个值了，仍到这里，说明不存在要删除的值！
153                 System.out.println("不存在要删除的值！");
154             }
155         }
156     }
157 
158     private void delete(T info,BTNode node)throws NoSuchElementException {
159         if (node == null) { //其实到这里，就一定存在要删除的值了。
160             throw new NoSuchElementException();
161         }else {
162             int i;
163             for(i=0;i<node.informations.size();i++){
164                 if(info.compareTo(node.informations.get(i))==0){
165                     node.informations.remove(i);    //删除关键字，其实要是索引向文件，也应该删除文件。
166                     break;
167                 }
168             }
169             if(node.ptr.size()>0){//删除一个非叶子节点的关键字后，如果有孩子，则判断孩子的孩子，如果孩子有孩子，则将右孩子的孩子最深左孩子的第一个值赋给删除关键字的节点
170                 //每一个关键字，一定有两个孩子
171                 if(node.ptr.get(i+1).ptr.size()==0){//孩子没有孩子的时候，只将孩子的最左关键字上升。
172                     node.informations.add(i,node.ptr.get(i+1).informations.get(0));
173                     node.ptr.get(i+1).informations.remove(0);
174                     if(node.ptr.get(i+1).informations.size()<n){
175                         dManageNode(node.ptr.get(i+1));
176                     }
177                 }else {//孩子有孩子的时候，则将右孩子的孩子最深左孩子的第一个值赋给删除关键字的节点
178                     pullRLeftNode(node,i,node.ptr.get(i+1),i);
179                 }
180 
181             }else {//如果没有孩子，要判断该节点关键字数量是否大于最小值
182                 if(node.informations.size()>=n){//大于等于就没事，不用动
183                     return;
184                 }else {//叶子节点中关键字数小于n，需要继续判断兄弟节点是否饱满
185                     dManageNode(node);
186                 }
187             }
188         }
189     }
190 
191     public String perOrder(BTNode node){
192         String result = "";
193         if(node.ptr.size()>0){
194             int i = 0;
195             for (BTNode n:node.ptr){
196                 result += perOrder(n);
197                 if(i<node.informations.size()){
198                     result += node.informations.get(i).toString()+",";
199                     ++i;
200                 }
201             }
202         }else {//叶子节点
203             if(node.informations.size()>0){
204                 for (T t:node.informations){
205                     result += t.toString()+",";
206                 }
207             }else {//叶子节点没有空值的时候，除非是根节点，根节点为空值的时候，说句话意思意思
208                 result += "B-树为空！";
209             }
210         }
211         return result;
212     }
213 
214     public void split(BTNode node){//进到这里的node都是m个关键字，需要提出m/2
215         if(node == null){
216             System.out.println("error");
217         }else {
218             if(node.informations.size()!=m){
219                 System.out.println("error");
220             }else {
221                 if(node.parent == null){//node是root时
222                     T temp = node.informations.get(n);//这里正好
223                     root = new BTNode(temp,null);
224                     node.informations.remove(n);//加进去了就要删掉！
225                     root.ptr.add(node);
226                     node.parent=root;
227                     splitNewNode(node,n,root);
228                 }else {//一个非根节点
229                     T temp = node.informations.get(n);
230                     node.parent.informations.add(node.parent.ptr.indexOf(node),temp);
231                     node.informations.remove(n);
232                     splitNewNode(node,n,node.parent);
233                     if (node.parent.informations.size()>=m){
234                         split(node.parent);
235                     }
236                 }
237             }
238         }
239     }
240 
241     public void splitNewNode(BTNode node,int n,BTNode parent){
242         BTNode newnode = new BTNode(node.informations.get(n),node.parent);
243 
244         newnode.informations.addAll(node.informations.subList(n+1,node.informations.size()));
245 
246         node.informations.removeAll(node.informations.subList(n,node.informations.size()));
247         //newnode.parent=node.parent;//新增节点的父节点
248         node.parent.ptr.add(node.parent.ptr.indexOf(node)+1,newnode);   //新增节点加到父节点上
249         if(node.ptr.size()>0){  //处理新增节点的孩子
250             newnode.ptr.addAll(node.ptr.subList(n+1,node.ptr.size()));
251             node.ptr.removeAll(node.ptr.subList(n+1,node.ptr.size()));
252             for (BTNode bn:newnode.ptr){    //子节点移到了新节点上，但是子节点的父节点没有处理！！！T_T
253                 bn.parent = newnode;
254             }
255         }
256 
257     }
258 
259     public void combine(BTNode lnode,BTNode rnode){
260         if(lnode.informations.size()<n){
261             lnode.informations.add(lnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
262             lnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
263         }else if(rnode.informations.size()<n){
264             rnode.informations.add(0,rnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
265             rnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
266         }else {
267             System.out.println("error");
268         }
269 
270         lnode.informations.addAll(rnode.informations);
271         lnode.ptr.addAll(rnode.ptr);
272         for (BTNode n:rnode.ptr){
273             n.parent=lnode;
274         }
275         lnode.parent.ptr.remove(lnode.parent.ptr.indexOf(lnode)+1);
276         if(lnode.parent.parent==null&&lnode.parent.informations.size()==0){//父节点是根节点
277             lnode.parent = null;    //lnode为新的根节点
278             root = lnode;
279             return;
280         }
281         if(lnode.parent.informations.size()<n){
282             dManageNode(lnode.parent);
283         }
284     }
285 
286     public void lrotate(BTNode lnode,BTNode rnode){
287         lnode.informations.add(lnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
288         lnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
289         lnode.parent.informations.add(lnode.parent.ptr.indexOf(lnode),rnode.informations.get(0));
290         rnode.informations.remove(0);
291         if(rnode.ptr.size()>0){//要判断叶子节点没有孩子！
292             lnode.ptr.add(rnode.ptr.get(0));
293             rnode.ptr.remove(0);
294             lnode.ptr.get(lnode.ptr.size()-1).parent=lnode;
295         }
296 
297     }
298 
299     public void rrotate(BTNode lnode,BTNode rnode){
300         rnode.informations.add(rnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
301         rnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
302         rnode.parent.informations.add(lnode.parent.ptr.indexOf(lnode),lnode.informations.get(lnode.informations.size()-1));
303         lnode.informations.remove(lnode.informations.size()-1);
304         if(lnode.ptr.size()>0){
305             rnode.ptr.add(0,lnode.ptr.get(lnode.ptr.size()-1));
306             lnode.ptr.remove(lnode.ptr.size()-1);
307             rnode.ptr.get(0).parent=rnode;
308         }
309     }
310 
311     public void dManageNode(BTNode node){//叶子节点中关键字数小于n，需要继续判断兄弟节点是否饱满，是旋转还是合并
312         if(node.parent==null){
313             return;
314         }else {
315             int x = node.parent.ptr.indexOf(node);
316             if(x==0){//被删除关键字所在节点，是父节点最左边的节点时，判断右兄弟，而且肯定有右兄弟
317                 if(node.parent.ptr.get(x+1).informations.size()==n){//刚脱贫，需要合并
318                     combine(node,node.parent.ptr.get(x+1));
319                 }else if(node.parent.ptr.get(x+1).informations.size()>n){//关键字数大于最小值，丰满
320                     lrotate(node, node.parent.ptr.get(x + 1));
321                 }else {
322                     System.out.println("error");
323                 }
324             }else if(x==node.parent.ptr.size()-1){//是父节点最右边的节点时，判断左兄弟
325                 if(node.parent.ptr.get(x-1).informations.size()==n){//左兄弟刚脱贫，需要合并
326                     combine(node.parent.ptr.get(x-1),node);
327                 }else if(node.parent.ptr.get(x-1).informations.size()>n){//关键字数大于最小值，丰满
328                     rrotate(node.parent.ptr.get(x-1),node);
329                 }else {
330                     System.out.println("error");
331                 }
332             }else {//node在父节点的子节点的中间，需要先判断左兄弟，再判断右兄弟。靠，感觉判断兄弟是否饱满，还是应该写一个函数，也许可以传递两个值
333                 //先跟饱满的借，除非两个兄弟都刚脱贫。
334                 if(node.parent.ptr.get(x-1).informations.size()>n){//左兄弟丰满
335                     rrotate(node.parent.ptr.get(x - 1),node);
336                 }else if(node.parent.ptr.get(x+1).informations.size()>n){//右兄弟丰满
337                     lrotate(node, node.parent.ptr.get(x + 1));
338                 }else{//左右兄弟都刚脱贫，需要合并
339                     combine(node.parent.ptr.get(x-1),node);
340                 }
341             }
342         }
343 
344     }
345 
346     public void pullRLeftNode(BTNode donode,int j,BTNode node,int i){//节点删除关键字后，如果该节点有孩子，则孩子需要贡献关键字，由于孩子减少了关键字还需要向下借，一直递归到叶子。
347 
348         if(node.ptr.get(0).ptr.size()>0){
349             pullRLeftNode(donode,j,node.ptr.get(0),0);
350         }else {
351             donode.informations.add(j,node.ptr.get(0).informations.get(0));
352             node.ptr.get(0).informations.remove(0);
353             if(node.ptr.get(0).informations.size()<n){
354                 dManageNode(node.ptr.get(0));
355             }
356         }
357     }
358 
359     class BTNode{
360         BTNode parent;  //父节点
361         List<T> informations = new ArrayList<T>();  //关键字的信息
362         List<BTNode> ptr = new ArrayList<BTNode>();     //分支
363 
364         public BTNode(T information,BTNode parent){
365             if(information != null){
366                 informations.add(information);
367                 this.parent = parent;
368             }else {
369                 this.parent = null;
370             }
371         }
372 
373         boolean isLeaf(){
374             return (ptr.size()==0);
375         }
376 
377         boolean isNode(){
378             return (ptr.size()!=0);
379         }
380 
381         int infoLength(){
382             return informations.size();
383         }
384 
385         int ptrLength(){
386             return ptr.size();
387         }
388 
389     }
390 
391     private static String stringInput(String inputRequest)throws IOException{
392         System.out.println(inputRequest);
393         return reader.readLine();
394     }
395 
396     public static void main(String[] args)throws IOException {
397         System.out.println("test B - balanced tree operations");
398         System.out.println("*****************************");
399 
400         String input;
401         Integer value;
402 
403         do {
404             input = stringInput("please select: [i]nsert, [d]elete, [s]how, [e]xit");
405             switch (input.charAt(0)) {
406                 case ‘i‘:
407                     value = Integer.parseInt(stringInput("insert: "), 10);
408                     tree.insert(value);
409                     break;
410                 case ‘d‘:
411                     value = Integer.parseInt(stringInput("delete: "), 10);
412                     tree.delete(value);
413                     break;
414                 case ‘s‘:
415                     System.out.println(tree.perOrder(tree.root));
416                     break;
417 //                case ‘h‘:
418 //                    System.out.println(tree.getHeight());
419             }
420         } while ((input.charAt(0) != ‘e‘));
421     }
422 }