编程内功修炼之数据结构—BTree（二）实现BTree插入、查询、删除操作

  1 package edu.algorithms.btree;

  2 

  3 import java.util.ArrayList;

  4 import java.util.List;

  5 

  6 /**

  7  * BTree类

  8  * 

  9  * @author lingfeng

 10  *

 11  */

 12 public class BTree {

 13     

 14     /**BTree 基础参数信息配置

 15     最小度数    t=2时，称作2-3-4数，表示只能存在2、3、4子女数**/

 16     private int t = 2;  

 17     

 18     /**非根节点最小关键字数**/

 19     private int minKeys = t-1;

 20     

 21     /**内节点最大关键字数**/

 22     private int maxKeys = 2*t - 1;

 23     

 24     /**树根节点**/

 25     private BTreeNode root;

 26     

 27     /**构造函数**/

 28     public BTree(){

 29         //初始化

 30         root = new BTreeNode();

 31         root.setLeaf(true);

 32     }

 33     /**构造函数  t 最小度数**/

 34     public BTree(int t){

 35         this();

 36         this.t  = t;

 37         minKeys = t - 1;

 38         maxKeys = 2*t - 1;

 39     }

 40     

 41     /**插入元素

 42      * 

 43      * 1.元素存在，插入元素

 44      * 2.元素不存在，插入元素

 45      * 

 46      * **/

 47     public void insertNode(Integer key){

 48         if(root.size() == maxKeys){   //根节点已满

 49             //进行根节点分割

 50             BTreeNode tmpNode = new BTreeNode();

 51             tmpNode.setLeaf(false);

 52             tmpNode.getChildrens().add(root);

 53             btreeSplitChild(tmpNode, 0, root);

 54             root = tmpNode;

 55         }

 56         insertRootNotFull(root, key);

 57     }

 58     

 59     public void insertRootNotFull(BTreeNode node, int key){

 60         

 61         //如果该节点为叶子节点

 62         if(node.isLeaf()){

 63             //寻找当前节点所有关键字

 64             ResultSearch result = divideSearch(node.getKeys(), key);

 65             //查询结果：成功  返回已经存在关键字位置

 66             if(result.result == true){

 67                 

 68             }else{    //查询结果：失败   返回插入位置

 69                 node.insertKey(key, result.index);

 70             }

 71             

 72         }else{

 73             //寻找当前节点所有关键字

 74             ResultSearch result = divideSearch(node.getKeys(), key);

 75             //查询结果：成功  返回已经存在关键字位置

 76             if(result.result == true){

 77                 

 78             }else{    //查询结果：失败   返回插入子女节点的位置

 79                 //判断子女状态

 80                 BTreeNode childNode = node.childAt(result.index);

 81                 if(node.childAt(result.index).size() == (2*t - 1)){

 82                     btreeSplitChild(node, result.index, childNode);

 83                     if(key > node.keyAt(result.index)){   //判断key落在 前半部分 或 后半部分

 84                         childNode = node.childAt(result.index + 1);

 85                     }

 86                 }

 87                 insertRootNotFull(childNode, key);

 88             }

 89         }

 90     }

 91     /**查询元素 (BTree查询)

 92      * 

 93      * 1.先查询节点的关键字列表

 94      * 2.失败则，查询子女节点；成功则，返回值

 95      * 3.递归搜索

 96      * 

 97      * **/

 98     public Integer search(BTreeNode node,Integer key){

 99         List<Integer> keys_tmp = node.getKeys();

100         ResultSearch result = divideSearch(keys_tmp, key);

101         if(result.result){

102             return result.index;

103         }else{

104             return search(node.childAt(result.index), key);

105         }

106     }

107     /**二分查询

108      * 参数 元素列表、所需要查询元素的值

109      * 

110      * **/

111     public ResultSearch divideSearch(List<Integer> elements, int key){

112         

113         int start = 0;    //扫描起始位置

114         int end   = 0;    //扫描结束位置

115         

116         end = elements.size() - 1;

117         

118         int mid = 0; 

119         while(start<=end){

120             mid   = (start + end)/2;

121             if(elements.get(mid) == key){ //满足等值条件

122                 break;

123             }else if(elements.get(mid) > key){ //在列表前半部分

124                 //改变扫描结束位置

125                 end = mid - 1;

126             }else if(elements.get(mid) <= key){

127                 //改变扫描开始位置

128                 start = mid + 1;

129             }

130         }

131         

132         boolean result = false;

133         Integer index = 0;

134         

135         if(start<=end){  //二分查找成功

136             result = true;

137             index = mid;

138         }else{    //查找失败，不存在元素

139             result = false;

140             index = start;

141         }

142         

143         return new ResultSearch(result,index);

144     }

145     

146     /**

147      * 节点分割函数

148      * @param parentNode  被分割节点的父节点

149      * @param index  被分割节点在父节点的第index个子女索引位置

150      * @param Node   被分割节点

151      */

152     public void btreeSplitChild(BTreeNode parentNode, int index, BTreeNode node){

153         

154         //新建一个节点，保存分割后[t+1 2t-1]数据

155         BTreeNode subNode = new BTreeNode();

156         //必须加上

157         subNode.setLeaf(node.isLeaf());

158         

159         for(int i=1; i<=minKeys ; i++){

160             subNode.getKeys().add(node.keyAt(t + i -1));

161         }

162         //保存分割点值[t]

163         Integer key = node.keyAt(t - 1);

164         //删除被分割节点的[t 2t-1]数据

165         for(int i= maxKeys - 1; i>=minKeys; --i){

166             node.getKeys().remove(i);

167         }

168         if(!node.isLeaf()){ //如果满节点不是叶节点，关键字分割后，需要将其子女进行操作

169             

170             //subNode应该拥有后半部分的子女

171             for(int i=0 ; i<minKeys+1 ; ++i){

172                 subNode.getChildrens().add(node.childAt(i+t));

173             }

174             //并删除node后半部分的子女

175             for(int i=maxKeys ; i>=minKeys+1; --i){

176                 node.getChildrens().remove(i);

177             }

178         }else{

179             

180         }

181         //将[t]数据加入父节点中去

182         parentNode.insertKey(key, index);

183         //将新节点关联到父节点index+1子女中

184         parentNode.insertChild(subNode, index+1);

185     }

186     public void delete(Integer key){

187         delete(root, key);

188     }

189     

190     public void delete(BTreeNode node, Integer key){

191         //删除关键字时，必须保证关键字大于等于t

192         assert node.size() >=t || node == root;

193         

194         //对当前节点进行二分查找

195         ResultSearch resultSearch = divideSearch(node.getKeys(), key);

196         

197         //成功

198         if(resultSearch.result){

199             

200             //如果当前节点属于叶子节点，可以直接进行删除

201             if(node.isLeaf()){

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

203             }else{

204                 //如果不是叶子节点 ，判断前于key子节点状态

205                 BTreeNode leftChildNode = node.childAt(resultSearch.index);

206                 if(leftChildNode.size() >= t){

207                     

208                     //从leftChildNode进行借值 代替当前需要删除的关键字

209                     //删除当前节点关键字

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

211                     node.insertKey(leftChildNode.keyAt(leftChildNode.size()-1), resultSearch.index);

212                     delete(leftChildNode, leftChildNode.keyAt(leftChildNode.size()-1));

213                 }else{

214                     

215                     BTreeNode rightChildNode = node.childAt(resultSearch.index + 1);

216                     if(rightChildNode.size() >= t){

217                         

218                         //从rightChildNode进行借值 代替当前需要删除的关键字

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

220                         node.insertKey(rightChildNode.keyAt(0), resultSearch.index);

221                         delete(rightChildNode, rightChildNode.keyAt(0));

222                     }else{

223                         

224                         //对于索引的左右子节点的数量都等于t-1

225                         //合适进行合并

226                         //1.将父节点删除  将节点右子节点删除

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

228                         node.getChildrens().remove(resultSearch.index.intValue() + 1);

229                         //2.将父节点添加到左子节点上

230                         leftChildNode.getKeys().add(key);

231                         //3.将删除的右子节点添加到左子节点上

232                         for(int i=0 ; i<rightChildNode.size() ; i++){

233                             leftChildNode.getKeys().add(rightChildNode.getKeys().get(i));

234                         }

235                         //如果右子节点非叶子节点，需要将其子女继承到左节点之下

236                         if(!rightChildNode.isLeaf()){

237                             for(int k=0 ; k<=rightChildNode.size() ; k++){

238                                 leftChildNode.getChildrens().add(rightChildNode.childAt(k));

239                             }

240                         }

241                         //递归删除

242                         delete(leftChildNode, key);

243                         

244                     }

245                 }

246                 

247             }

248             

249         }else{ //失败

250             if(node.isLeaf()){

251                 //不存在删除的对象

252                 System.out.println("不存在删除的对象");

253                 return ;

254             }

255             

256             //获取子节点

257             BTreeNode childNode = node.childAt(resultSearch.index);

258             

259             if(root == node && node.size()==0){

260                 root = childNode;

261             }

262             

263             if(childNode.size() >= t){   //如果满足递归条件

264                 delete(childNode, key);

265             }else{

266                 //不满足size == t

267                 //采取借关键字手段

268                 

269                 BTreeNode subNode = null;

270                 int subIndex = 0;

271                 //先检测右兄弟节点

272                 if(resultSearch.index < node.size()){

273                     if(node.childAt(resultSearch.index+1).size() >=t){

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

275                         subIndex = resultSearch.index + 1;

276                     }

277                 }

278                 //测试左兄弟节点

279                 if(subNode == null){

280                     if(resultSearch.index > 0){

281                         if(node.childAt(resultSearch.index-1).size() >= t){

282                             subNode  = node.childAt(resultSearch.index-1);

283                             subIndex = resultSearch.index - 1;

284                         }

285                     }

286                 }

287                 //测试完成后

288                 if(subNode != null){  //存在兄弟节点大于等于t情况

289                     //判断节点

290                     if(subIndex > resultSearch.index){ //右兄弟

291                         

292                         //将右关键字插入自身

293                         childNode.insertKey(node.keyAt(subIndex - 1), childNode.size());

294                         node.getKeys().remove(subIndex - 1);

295                         node.insertKey(subNode.keyAt(0), subIndex - 1);

296                         subNode.getKeys().remove(0);

297                         

298                         //右兄弟非子叶节点，则带有孩子节点

299                         if(!subNode.isLeaf()){

300                             childNode.getChildrens().add(subNode.getChildrens().get(0));

301                             subNode.getChildrens().remove(0);

302                         }

303                         

304                     }else{  //左兄弟

305                         

306                         //将左关键字插入自身最前位置

307                         childNode.insertKey(node.keyAt(subIndex), 0);

308                         node.getKeys().remove(subIndex);

309                         node.insertKey(subNode.keyAt(subNode.size()-1), subIndex);

310                         subNode.getKeys().remove(subNode.size()-1);

311                         

312                         //如果左兄弟非子叶节点

313                         if(!subNode.isLeaf()){

314                             childNode.insertChild(subNode.childAt(subNode.size()), 0);

315                             subNode.getChildrens().remove(subNode.size()-1);

316                         }    

317                     }

318                     delete(childNode, key);

319                     

320                 }else{

321                     

322                     //该节点的左右兄弟节点关键字都为t-1

323                     //选择合并方案

324                     if(resultSearch.index < node.size()){   //右兄弟存在

325                         

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

327                         

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

329                         childNode.getKeys().add(node.keyAt(resultSearch.index));

330                         

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

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

333                         

334                         for(int i=0 ; i<subNode.size() ; i++){

335                             childNode.getKeys().add(subNode.keyAt(i));

336                         }

337                         

338                         if(!subNode.isLeaf()){

339                             for(int k=0 ; k<=subNode.size(); k++){

340                                 childNode.getChildrens().add(subNode.childAt(k));

341                             }

342                         }

343                         

344                     }else{      //左兄弟存在

345                         

346                         subNode = node.childAt(resultSearch.index - 1);

347                         childNode.insertKey(node.keyAt(resultSearch.index-1), 0);

348                         node.getKeys().remove(resultSearch.index - 1);

349                         node.getChildrens().remove(resultSearch.index-1);

350                         

351                         for(int i=subNode.size()-1 ; i>=0 ; --i){

352                             childNode.insertKey(subNode.keyAt(i), 0);

353                         }

354                         

355                         if(!subNode.isLeaf()){

356                             for(int k=subNode.size() ; k>=0 ; --k){

357                                 childNode.insertChild(subNode.childAt(k),0);

358                             }

359                         }

360                         

361                     }

362                     if(root == node && node.size() == 0){

363                         root = childNode;

364                     }

365                     delete(childNode, key);

366                 }

367             }

368             

369         }

370     }

371     

372 }

373 class BTreeNode{

374     

375     /**当前节点keys列表**/

376     private List<Integer> keys; 

377 

378     /**当前节点的child列表**/

379     private List<BTreeNode> childrens;

380     

381     /**是否是叶子节点**/

382     private boolean leaf;

383     

384     public BTreeNode(){

385         keys      = new ArrayList<Integer>();

386         childrens = new ArrayList<BTreeNode>();

387         leaf = true;

388     }

389     /**

390      * set and get methods

391      * 

392      * **/

393     public List<Integer> getKeys() {

394         return keys;

395     }

396     public void setKeys(List<Integer> keys) {

397         this.keys = keys;

398     }

399     public List<BTreeNode> getChildrens() {

400         return childrens;

401     }

402     public void setChildrens(List<BTreeNode> childrens) {

403         this.childrens = childrens;

404     }

405     public boolean isLeaf() {

406         return leaf;

407     }

408     public void setLeaf(boolean leaf) {

409         this.leaf = leaf;

410     }

411     

412     /**

413      * 获取子女节点

414      * @param index

415      * @return

416      */

417     public BTreeNode childAt(int index){

418         return childrens.get(index);

419     }

420     /**

421      * 获取关键字

422      * @param index

423      * @return

424      */

425     public Integer keyAt(int index){

426         return keys.get(index);

427     }

428     

429     /**

430      * 获取节点关键字数量

431      * @return

432      */

433     public int size(){

434         return keys.size();

435     }

436     

437     /**

438      * 插入key到指定的index中去

439      * @param key

440      * @param index

441      */

442     public void insertKey(Integer key, int index){

443         //插入key到指定的索引位置

444         //保存索引前的所有关键字

445         List<Integer> newlist = new ArrayList<Integer>();

446         

447         for(int i=0; i<index ; i++){

448             newlist.add(keys.get(i));

449         }

450         //插入关键字

451         newlist.add(key);

452         //保存索引后多关键字

453         for(int i=index ; i<keys.size() ; i++){

454             newlist.add(keys.get(i));

455         }

456         //将新的关键字集合设置为节点关键字集合对象

457         keys = newlist;

458     }

459     

460     /**

461      * 插入node子女到指定的index位置

462      * @param node

463      * @param index

464      */

465     public void insertChild(BTreeNode node, int index){

466         //插入child

467         List<BTreeNode> newlist = new ArrayList<BTreeNode>();

468         for(int i=0 ; i< index ; i++){

469             newlist.add(childrens.get(i));

470         }

471         newlist.add(node);

472         for(int i=index ; i<childrens.size() ; i++){

473             newlist.add(childrens.get(i));

474         }

475         childrens = newlist;

476     }

477 }

478 /**

479  * 查询结果类

480  * result 标识成功的状态 true or false

481  * index 成功后返回元素的索引

482  *       失败后返回元素的插入位置 

483  * @author lingfeng

484  */

485 class ResultSearch{

486     

487     public Integer index;

488     public boolean result;

489     

490     public ResultSearch(boolean rs, Integer i){

491         index  = i;

492         result = rs;

493     }

494 }