编程内功修炼之数据结构—BTree（三）总结

BTree必须通过各种编程约束，使得不脱离BTree的本身特性；

1）BTree关键字插入操作；插入过程中，如果节点关键字达到上限，添加分裂约束，从而控制每个节点的关键字数维持在 t-1~2*t-1内；

2）BTree节点中的关键字查询；因为关键字按非降序进行排列，所以可以采用二分查找方法进行查询，以提高算法性能；

3）BTree关键字删除操作；

　删除操作必须保证节点关键字数n[x]>=t，这样删除一个关键字才不会违反BTree规则。

当前节点是叶节点，可以直接删除；

当前节点是内节点，可以寻找左右子女节点进行关键字替代；

当前节点不足t方案：

　　　　（a）如果当前节点关键字不足t，可以向兄弟节点进行借取；

　 （b）如果左右相近兄弟节点都不满足>=t要求，那么可以采用合并方式；

Delete实现方法如下：

 public void delete(BTreeNode node, Integer key){
         //删除关键字时，必须保证关键字大于等于t
         assert node.size() >=t || node == root;

         //对当前节点进行二分查找
         ResultSearch resultSearch = divideSearch(node.getKeys(), key);

         //成功
         if(resultSearch.result){

             //如果当前节点属于叶子节点，可以直接进行删除
             if(node.isLeaf()){
                 node.getKeys().remove(resultSearch.index.intValue());
             }else{
                 //如果不是叶子节点 ，判断前于key子节点状态
                 BTreeNode leftChildNode = node.childAt(resultSearch.index);
                 if(leftChildNode.size() >= t){

                     //从leftChildNode进行借值 代替当前需要删除的关键字
                     //删除当前节点关键字
                     node.getKeys().remove(resultSearch.index.intValue());
                     node.insertKey(leftChildNode.keyAt(leftChildNode.size()-1), resultSearch.index);
                     delete(leftChildNode, leftChildNode.keyAt(leftChildNode.size()-1));
                 }else{

                     BTreeNode rightChildNode = node.childAt(resultSearch.index + 1);
                     if(rightChildNode.size() >= t){

                         //从rightChildNode进行借值 代替当前需要删除的关键字
                         node.getKeys().remove(resultSearch.index.intValue());
                         node.insertKey(rightChildNode.keyAt(0), resultSearch.index);
                         delete(rightChildNode, rightChildNode.keyAt(0));
                     }else{

                         //对于索引的左右子节点的数量都等于t-1
                         //合适进行合并
                         //1.将父节点删除  将节点右子节点删除
                         node.getKeys().remove(resultSearch.index.intValue());
                         node.getChildrens().remove(resultSearch.index.intValue() + 1);
                         //2.将父节点添加到左子节点上
                         leftChildNode.getKeys().add(key);
                         //3.将删除的右子节点添加到左子节点上
                         for(int i=0 ; i<rightChildNode.size() ; i++){
                             leftChildNode.getKeys().add(rightChildNode.getKeys().get(i));
                         }
                         //如果右子节点非叶子节点，需要将其子女继承到左节点之下
                         if(!rightChildNode.isLeaf()){
                             for(int k=0 ; k<=rightChildNode.size() ; k++){
                                 leftChildNode.getChildrens().add(rightChildNode.childAt(k));
                             }
                         }
                         //递归删除
                         delete(leftChildNode, key);

                     }
                 }

             }

         }else{ //失败
             if(node.isLeaf()){
                 //不存在删除的对象
                 System.out.println("不存在删除的对象");
                 return ;
             }

             //获取子节点
             BTreeNode childNode = node.childAt(resultSearch.index);

             if(root == node && node.size()==0){
                 root = childNode;
             }

             if(childNode.size() >= t){   //如果满足递归条件
                 delete(childNode, key);
             }else{
                 //不满足size == t
                 //采取借关键字手段

                 BTreeNode subNode = null;
                 int subIndex = 0;
                 //先检测右兄弟节点
                 if(resultSearch.index < node.size()){
                     if(node.childAt(resultSearch.index+1).size() >=t){
                         subNode  = node.childAt(resultSearch.index+1);
                         subIndex = resultSearch.index + 1;
                     }
                 }
                 //测试左兄弟节点
                 if(subNode == null){
                     if(resultSearch.index > 0){
                         if(node.childAt(resultSearch.index-1).size() >= t){
                             subNode  = node.childAt(resultSearch.index-1);
                             subIndex = resultSearch.index - 1;
                         }
                     }
                 }
                 //测试完成后
                 if(subNode != null){  //存在兄弟节点大于等于t情况
                     //判断节点
                     if(subIndex > resultSearch.index){ //右兄弟

                         //将右关键字插入自身
                         childNode.insertKey(node.keyAt(subIndex - 1), childNode.size());
                         node.getKeys().remove(subIndex - 1);
                         node.insertKey(subNode.keyAt(0), subIndex - 1);
                         subNode.getKeys().remove(0);

                         //右兄弟非子叶节点，则带有孩子节点
                         if(!subNode.isLeaf()){
                             childNode.getChildrens().add(subNode.getChildrens().get(0));
                             subNode.getChildrens().remove(0);
                         }

                     }else{  //左兄弟

                         //将左关键字插入自身最前位置
                         childNode.insertKey(node.keyAt(subIndex), 0);
                         node.getKeys().remove(subIndex);
                         node.insertKey(subNode.keyAt(subNode.size()-1), subIndex);
                         subNode.getKeys().remove(subNode.size()-1);

                         //如果左兄弟非子叶节点
                         if(!subNode.isLeaf()){
                             childNode.insertChild(subNode.childAt(subNode.size()), 0);
                             subNode.getChildrens().remove(subNode.size()-1);
                         }
                     }
                     delete(childNode, key);

                 }else{

                     //该节点的左右兄弟节点关键字都为t-1
                     //选择合并方案
                     if(resultSearch.index < node.size()){   //右兄弟存在

                         subNode = node.childAt(resultSearch.index + 1);

                         //childNode.getKeys().add(node.keyAt(resultSearch.index + 1));
                         childNode.getKeys().add(node.keyAt(resultSearch.index));

                         node.getKeys().remove(resultSearch.index.intValue());
                         node.getChildrens().remove(resultSearch.index.intValue());

                         for(int i=0 ; i<subNode.size() ; i++){
                             childNode.getKeys().add(subNode.keyAt(i));
                         }

                         if(!subNode.isLeaf()){
                             for(int k=0 ; k<=subNode.size(); k++){
                                 childNode.getChildrens().add(subNode.childAt(k));
                             }
                         }

                     }else{      //左兄弟存在

                         subNode = node.childAt(resultSearch.index - 1);
                         childNode.insertKey(node.keyAt(resultSearch.index-1), 0);
                         node.getKeys().remove(resultSearch.index - 1);
                         node.getChildrens().remove(resultSearch.index-1);

                         for(int i=subNode.size()-1 ; i>=0 ; --i){
                             childNode.insertKey(subNode.keyAt(i), 0);
                         }

                         if(!subNode.isLeaf()){
                             for(int k=subNode.size() ; k>=0 ; --k){
                                 childNode.insertChild(subNode.childAt(k),0);
                             }
                         }

                     }
                     if(root == node && node.size() == 0){
                         root = childNode;
                     }
                     delete(childNode, key);
                 }
             }

         }
     }