B树——思路、及C语言代码的实现
0.序
本人现读本科大二，这学期学习数据结构，老师为我们的期末作业布置一道任选题，而我一直以来都有听说B树是一棵挺神奇的树，所以我选择了它，当然更重要的原因是因为B树的难度最高，我喜欢做有挑战性的工作。同时，我听我基友说他热衷于将自己所学所想分享到博客园上，故才有了这样一篇文章。希望我能够在写博客的同时学习到更多东西，同时也能帮助到其他遇到或者即将遇到雷同问题的初学者们。
1.关于B树
B树是一种称之为查找树的树，与之类似的有查找二叉树，平衡二叉树，除此之外，还有各种B树的兄弟姐妹B+树、B-树、B*树等，他们共同的特点就是都是按照一定的顺序规律存储的。B树的应用也是很广泛的，B树是几乎所有数据库的默认索引结构，也是用的最多的索引结构。B树是一种多叉树，根据其最多叉的数目可以直接称为M阶B树。根据算法导论上叙述，还可按B树每个节点最少的分支确定一棵B树的阶，但是这样的话B树的阶便必须为偶数。我个人是使用根据最大分支的数目确定B树的阶的。
下图就是某一棵B树，每一个结点中都包含有数个数据元素，而同时一定会有数据元素的个数加一个的子树。
一棵M阶B树或为空树，或为满足下列特性的M叉树：
（1）树中每个结点最多含有M棵子树；
（2）若根结点不是叶子结点，则至少有2棵子树；
（3）除根结点之外的所有非终端结点至少有[m/2]棵子树；
（4）每个非终端结点中包含的信息keynum，ptr[0],key[1],ptr[1],key[2],ptr[2],……key[keynum],ptr[keynum];
其中，key为关键字，且关键字按升序排序，ptr为指向子树的根结点指针
2.思路及实现
B树的接口主要是插入（包括空树插入一个元素）和删除操作，而插入和删除操作不可避免的都会用到查找操作，而查找的主要思路比较简单，主要是利用B树是一种排序树的原理，可以很快找到要插入位置或者要删除结点。这里的关键是注意返回内容包括查找结果所在结点，以及该元素所在位置，这是为了方便接下来的操作比较简单。
插入：
通过对B树进行遍历，找出要插入的结点以及结点位置，如果找到的key值在B树当中已经存在，则说明插入失败，否则，就可以进行插入操作。这里可以先不管是否超出M阶树的上限要求，因为我们在定义的时候会故意留下一个位置，可以存放多余的一个元素，插入之后，通过判断是否达到M阶树上限要求，再进行递归的分裂操作。
1 /*** 2 * @name Status insertBTree(BTree &T, Record e) 3 * @description 插入实现元素的插入 4 * @return 成功返回OK,如果存在则返回FALSE，否则返回ERROR 5 * @notice 6 ***/ 7 Status insertBTree(BTree &T, Record e) 8 { 9 BTree p; 10 int index, temp; 11 Status find_flag; 12 if (NULL == T)//考虑B树为空树的情况 13 { 14 T = (BTree)malloc(BTLEN); 15 if (NULL == T) return OVERFLOW; 16 T->keynum = 1; 17 T->parent = NULL; 18 for (index = 0;index <= m; ++index) 19 { 20 T->ptr[index] = NULL; 21 T->key[index] = 0; 22 } 23 T->key[1] = e.key; 24 return OK; 25 } 26 find_flag = findBTree(T, p, temp, e.key);//寻找插入节点 27 if (find_flag == TRUE) 28 { 29 return FALSE; 30 } 31 if (find_flag == FALSE) 32 { //不管怎样先直接插入 33 p->keynum++; 34 for (index = p->keynum;index > temp;--index) 35 { 36 p->key[index] = p->key[index - 1]; 37 p->ptr[index] = p->ptr[index - 1]; 38 } 39 p->ptr[temp] = NULL; 40 p->key[temp] = e.key; 41 if (p->keynum == m) //这种情况得分裂 42 { 43 splitBTree(p); 44 } 45 renewParent(T); 46 return OK; 47 } 48 return ERROR; 49 }
分裂：
分裂操作是插入操作过程中一个最重要的操作，因为这是处理“冲突”（即结点中的数据元素大于B树规则中要求的最大个数）的一个通用的处理方式，这种方式必须要对所有的情况都适用，而分裂是解决这一问题一个方法。当然这种方法只是考虑到效率，没有对兄弟可否借数据进行判断，但是另外一种方式比较麻烦，这里先不做讨论。
分裂的思路是让父亲结点先腾出一个位置（包括key和ptr）出来，然后在需要分裂的结点里面取中间的元素并且移动中间的元素key到父亲结点已经腾出来的key位置那里，然后把分裂出来的右部分接到腾出来的ptr那里。注意整个过程对左部分和右部分的都要改变元素的个数以及清空一些没用的空间。在往上分裂之后可能会造成一种情况，就是父亲结点也可能达到分裂的最大个数，所以，检查父亲结点是否需要分裂，需要的话，递归之。
1 /*** 2 * @name status splitBTree(BTree T) 3 * @description 递归实现分裂节点操作 4 * @return 成功返回OK,否则返回ERROR 5 * @notice 6 ***/ 7 Status splitBTree(BTree T) //此时分裂的节点一定会是超出最大值的。 8 { 9 BTree t1, t2; 10 int index, index_1; 11 if (T->parent == NULL) 12 { 13 t1 = (BTree)malloc(BTLEN); 14 if (NULL == t1) return OVERFLOW; 15 t2 = (BTree)malloc(BTLEN); 16 if (NULL == t2) return OVERFLOW; 17 18 t1->keynum = m / 2; 19 t2->keynum = m - (m / 2) - 1; 20 t1->parent = T; 21 t2->parent = T; 22 for (index = 0;index <= m; ++index) //先全部初始化 23 { 24 t1->ptr[index] = NULL; 25 t1->key[index] = 0; 26 t2->ptr[index] = NULL; 27 t2->key[index] = 0; 28 } 29 for (index = 0;index <= m / 2; ++index) //初始化t1 30 { 31 t1->ptr[index] = T->ptr[index]; 32 t1->key[index] = T->key[index]; 33 } 34 t2->ptr[0] = T->ptr[(m / 2) + 1]; 35 for (index = (m / 2) + 2;index <= m; ++index) //初始化t2 36 { 37 t2->ptr[index - ((m / 2) + 1)] = T->ptr[index]; 38 t2->key[index - ((m / 2) + 1)] = T->key[index]; 39 } 40 T->keynum = 1; 41 T->ptr[0] = t1; 42 T->ptr[1] = t2; 43 T->key[1] = T->key[m / 2 + 1]; 44 for (index = 2;index <= m; ++index) //初始化T 45 { 46 T->ptr[index] = NULL; 47 T->key[index] = 0; 48 } 49 return OK; 50 }
删除：
B树元素的删除操作与插入操作类似，但是却要麻烦，因为得分两种情况处理。（1）寻找到存在这个元素，而且这个元素所在是叶子节点（即它的孩子为空），直接对其进行删除，之后再判断是否小于B树规则中要求的最小的子树个数。如果小于，那就调用合并函数。（2）如果寻找到的这个元素是非叶子节点的元素，通过寻找比该元素小的最大元素（该元素肯定为叶子节点），把该元素直接赋值给要删除的元素，再在叶子节点处进行（1）中的操作。
1 /*** 2 * @name Status deleteBTreeRecord(BTree &T, Record e) 3 * @description 实现B树元素的删除 4 * @return 成功返回OK,否则返回ERROR 5 * @notice 6 ***/ 7 Status deleteBTreeRecord(BTree &T, Record e) 8 { 9 BTree p, q; 10 int num, temp, index; 11 Status find_flag; 12 if (T == NULL) 13 return ERROR; 14 find_flag = findBTree(T, p, temp, e.key); 15 if (find_flag == FALSE) 16 { 17 return FALSE; 18 } 19 if (find_flag == TRUE) 20 { 21 //deleteBTreeBNode(p,temp); 22 if (p->ptr[temp] == NULL) //如果是叶子节点的话 23 { 24 for (index = temp;index <= p->keynum;++index) 25 { 26 p->key[index] = p->key[index + 1]; 27 p->ptr[index] = p->ptr[index + 1]; 28 } 29 p->keynum--; 30 if (p->keynum == (m + 1) / 2 - 2) 31 { 32 //调用借兄弟的函数 33 if (borrowBNode(p) == EMPTY) T = NULL; 34 else renewParent(T); 35 } 36 return OK; 37 } 38 else //不是叶子结点的话 39 { 40 //遍历 41 findMax(p->ptr[temp - 1], q, num);//返回的q一定会是叶子节点 42 p->key[temp] = q->key[num]; 43 q->key[num] = 0; 44 q->keynum--; 45 if (q->keynum == (m + 1) / 2 - 2) 46 { 47 //调用借兄弟的函数 48 if (borrowBNode(q) == EMPTY) T = NULL; 49 else renewParent(T); 50 } 51 return OK; 52 } 53 return OK; 54 } 55 return ERROR; 56 }
合并:
在此先声明，因为一开始只考虑B树的阶为4的情况，后来改为使用宏定义阶M的数值，所以这段代码存在BUG，只支持阶为3或4的B树= =。
思路还是挺清晰的，首先先向兄弟结点借元素，如果兄弟能够借给你元素的话（即借了你之后并不会小于最少的分支），那么直接从兄弟那里取元素，否则，和兄弟合并。
合并其实是分裂反过来的情况，从父亲结点那里取出一个key值介于要合并的两个结点之间的元素，插入左部分最末尾处，同时右部分插到左部分后面，然后父亲结点元素依次往前挪。从而实现合并操作。之后，也必须对父亲结点进行判断是否小于最小的分支数，如果也小于，对父亲节点进行递归操作。
1 /*** 2 * @name Status borrowBNode(BTree &T) 3 * @description 递归实现，向兄弟借元素，否则和兄弟合并 4 * @return 成功返回OK,否则返回ERROR 5 * @notice 这种情况应该是T为单元素结点 6 ***/ 7 Status borrowBNode(BTree T) 8 { 9 int mynum, bronum, index; 10 BTree b = NULL, f = NULL; 11 if (T == NULL) return ERROR; 12 f = T->parent; 13 if (f == NULL)//考虑父亲结点不存在的情况 14 { 15 if (T->keynum == 0) 16 { 17 f = T->ptr[0]; 18 if (f == NULL) 19 { 20 free(T); 21 return EMPTY; 22 } 23 for (index = 0;index <= f->keynum;index++) 24 { 25 T->key[index] = f->key[index]; 26 T->ptr[index] = f->ptr[index]; 27 } 28 T->keynum = f->keynum; 29 free(f); 30 renewParent(T); 31 } 32 return OK; 33 } 34 mynum = whichSon(T); 35 if (mynum == 0) 36 bronum = 1; 37 else 38 bronum = mynum - 1; 39 b = f->ptr[bronum]; 40 if (b->keynum == (m + 1) / 2 - 1) //如果兄弟帮不了你了 41 { 42 //那么就和这个兄弟合体 43 if (bronum < mynum) //如果我不是第一个 44 { 45 b->keynum++; 46 b->key[b->keynum] = f->key[mynum]; 47 b->ptr[b->keynum] = T->ptr[0]; 48 for (index = 1;index <= T->keynum;index++) 49 { 50 b->key[index + b->keynum] = T->key[index]; 51 b->ptr[index + b->keynum] = T->ptr[index]; 52 b->keynum++; 53 } 54 free(T); 55 for (index = mynum;index <= f->keynum;index++) 56 { 57 f->key[index] = f->key[index + 1]; 58 f->ptr[index] = f->ptr[index + 1]; 59 } 60 f->keynum--; 61 } 62 else 63 { 64 T->keynum++; 65 T->key[T->keynum] = f->key[bronum]; 66 T->ptr[T->keynum] = b->ptr[0]; 67 for (index = 1;index <= b->keynum;index++) 68 { 69 T->key[index + T->keynum] = b->key[index]; 70 T->ptr[index + T->keynum] = b->ptr[index]; 71 T->keynum++; 72 } 73 free(b); 74 for (index = bronum;index <= f->keynum;index++) 75 { 76 f->key[index] = f->key[index + 1]; 77 f->ptr[index] = f->ptr[index + 1]; 78 } 79 f->keynum--; 80 } 81 renewParent(f); 82 if (f->keynum == (m + 1) / 2 - 2) 83 { 84 //调用借兄弟的函数 85 return borrowBNode(f); 86 } 87 } 88 else//如果兄弟能够帮你 89 { 90 if (bronum < mynum) //如果我不是第一个 91 { 92 for (index = 1;index <= T->keynum;index++) 93 { 94 T->key[index + 1] = T->key[index]; 95 T->ptr[index + 1] = T->ptr[index]; 96 } 97 T->ptr[1] = T->ptr[0]; 98 T->key[1] = f->key[mynum]; 99 T->ptr[0] = b->ptr[b->keynum]; 100 T->keynum++; 101 f->key[mynum] = b->key[b->keynum]; 102 b->key[b->keynum] = 0; 103 b->ptr[b->keynum] = NULL; 104 b->keynum--; 105 106 } 107 else //如果我是第一个 108 { 109 T->keynum++; 110 T->key[T->keynum] = f->key[1]; 111 T->ptr[T->keynum] = b->ptr[0]; 112 f->key[1] = b->key[1]; 113 b->ptr[0] = b->ptr[1]; 114 for (index = 1;index <= b->keynum;index++) 115 { 116 b->key[index] = b->key[index + 1]; 117 b->ptr[index] = b->ptr[index + 1]; 118 } 119 b->keynum--; 120 } 121 } 122 return OK; 123 }
遍历，输出：
为了让B树更容易看，代码更容易调试，我同时还用队列写了个层次遍历，这个看看就好，实现起来挺麻烦的。而且可能代码实现也存在问题
1 /*** 2 * @name Status ergodic(BTree T, LinkList L, int newline, int sum) 3 * @description print需要用到的递归遍历程序 4 * @return 成功返回OK 5 * @notice 此处用到队列 6 ***/ 7 Status ergodic(BTree T, LinkList L, int newline, int sum) 8 { 9 int index; 10 BTree p; 11 if (T != NULL) 12 { 13 printf("[ "); 14 Enqueue_L(L, T->ptr[0]); 15 for (index = 1;index <= T->keynum; index++) 16 { 17 printf("%d ", T->key[index]); 18 Enqueue_L(L, T->ptr[index]); 19 } 20 sum += T->keynum + 1; 21 printf("]"); 22 if (newline == 0) 23 { 24 printf("\n"); 25 newline = sum - 1; 26 sum = 0; 27 } 28 else 29 { 30 --newline; 31 } 32 } 33 if (IfEmpty(L) == FALSE) 34 { 35 Dequeue_L(L, p); 36 ergodic(p, L, newline, sum); 37 } 38 return OK; 39 } 40 /*** 41 * @name Status print(BTree T) 42 * @description 层次遍历并分层输出B树 43 * @return 成功返回OK 44 * @notice 45 ***/ 46 Status print(BTree T) 47 { 48 LinkList L; 49 if (T == NULL) 50 { 51 printf("[ ]\n"); 52 return OK; 53 } 54 InitQueue_L(L); 55 ergodic(T, L, 0, 0); 56 DestroyQueue(L); 57 return OK; 58 }
3.测试
4.总结
以目前所掌握的知识，终于把B树做出来了，整个过程没有参考过其他人的代码，所以并不知道自己的一些思路是否得当，如有错误，多多包涵。在整个过程中，最难，卡的最久的也就是合并操作了，这块的代码也是乱得掉渣，以后有时间把他完善了。最后附上完整代码。
1 #define _CRT_SECURE_NO_WARNINGS 2 #include<stdio.h> 3 #include<stdlib.h> 4 #include<time.h> 5 #define BTREELENGTH 50 6 #define BTLEN (sizeof(BTNode)) 7 #define MAXINT 100 8 typedef enum status 9 { 10 TRUE, 11 FALSE, 12 OK, 13 ERROR, 14 OVERFLOW, 15 EMPTY 16 }Status; 17 typedef int KeyType; 18 19 //**********************************B树**************************************** 20 #define m 3 // B树的阶，此设为4 21 typedef struct 22 { 23 KeyType key; 24 char data; 25 } Record; 26 typedef struct BTNode 27 { 28 int keynum; // 结点中关键字个数，即结点的大小 29 struct BTNode *parent; // 指向双亲结点 30 KeyType key[m + 1]; // 关键字向量，0号单元未用 31 struct BTNode *ptr[m + 1]; // 子树指针向量 32 // Record *recptr[m + 1]; // 记录指针向量，0号单元未用 33 //在此添加其他自定义数据 34 } BTNode, *BTree; // B树结点和B树的类型 35 typedef struct 36 { 37 BTNode *pt; // 指向找到的结点 38 int i; // 1..m，在结点中的关键字序号 39 int tag; // 1:查找成功，0:查找失败 40 } Result; // 在B树的查找结果类型 41 //**********************************B树**************************************** 42 43 //**********************************队列*************************************** 44 typedef struct LNode { 45 BTree data; // 数据域 46 struct LNode *next; // 指针域 47 } LNode, *LinkList; 48 //**********************************队列*************************************** 49 50 /*** 51 * @name Status InitQueue_L(LinkList &L) 52 * @description 初始化队列 53 * @return 成功返回OK，开辟空间失败返回OVERFLOW 54 * @notice 55 ***/ 56 Status InitQueue_L(LinkList &L) 57 { // 初始化一个只含头结点的空单链表L 58 if (NULL == (L = (LNode*)malloc(sizeof(LNode)))) // 生成新结点 59 return OVERFLOW; 60 L->next = NULL; 61 return OK; 62 } 63 /*** 64 * @name LNode* MakeNode_L(BTree e) 65 * @description 构造队列结点 66 * @return 返回结点地址 67 * @notice 68 ***/ 69 LNode* MakeNode_L(BTree e) 70 { // 构造数据域为e的单链表结点 71 LNode *p; 72 p = (LNode*)malloc(sizeof(LNode)); // 分配结点空间 73 if (p != NULL) 74 { 75 p->data = e; 76 p->next = NULL; 77 } 78 return p; 79 } 80 /*** 81 * @name Status Enqueue_L(LNode *p, BTree e) 82 * @description 队列的入队 83 * @return 成功返回OK，否则返回ERROR 84 * @notice 85 ***/ 86 Status Enqueue_L(LNode *p, BTree e) 87 { //在p结点之后插入q结点 88 if (NULL == p) return ERROR; // 参数不合理 89 while (p->next != NULL) 90 p = p->next; 91 p->next = MakeNode_L(e); // 对应图4.11（b）的②，修改p结点的指针域 92 return OK; 93 } 94 95 /*** 96 * @name Status Dequeue_L(LNode *p, BTree &e) 97 * @description 队列的出队 98 * @return 成功返回OK，否则返回ERROR 99 * @notice 100 ***/ 101 Status Dequeue_L(LNode *p, BTree &e) 102 { 103 // 删除p结点的直接后继结点并用参数e返回被删结点的值 104 LNode *q; 105 if (NULL == p || NULL == p->next) return ERROR; // 删除位置不合理 106 q = p->next; 107 p->next = q->next; // 修改被删结点q的指针域 108 e = q->data; 109 free(q); // 释放结点q 110 return OK; 111 } 112 113 /*** 114 * @name void DestroyQueue(LinkList L) 115 * @description 队列的销毁 116 * @return 无返回 117 * @notice 118 ***/ 119 void DestroyQueue(LinkList L) 120 { 121 // 销毁整个链表 122 LinkList p; 123 if (L != NULL) 124 { 125 p = L; 126 L = L->next; 127 free(p); 128 DestroyQueue(L); 129 } 130 } 131 /*** 132 * @name Status IfEmpty(LinkList L) 133 * @description 判断队列是否为空 134 * @return 空返回TRUE，不空返回FALSE，否则返回ERROR 135 * @notice 136 ***/ 137 Status IfEmpty(LinkList L) 138 { 139 if (L == NULL) return ERROR; 140 if (L->next == NULL) return TRUE; 141 return FALSE; 142 } 143 /*** 144 * @name Status ergodic(BTree T, LinkList L, int newline, int sum) 145 * @description print需要用到的递归遍历程序 146 * @return 成功返回OK 147 * @notice 此处用到队列 148 ***/ 149 Status ergodic(BTree T, LinkList L, int newline, int sum) 150 { 151 int index; 152 BTree p; 153 if (T != NULL) 154 { 155 printf("[ "); 156 Enqueue_L(L, T->ptr[0]); 157 for (index = 1;index <= T->keynum; index++) 158 { 159 printf("%d ", T->key[index]); 160 Enqueue_L(L, T->ptr[index]); 161 } 162 sum += T->keynum + 1; 163 printf("]"); 164 if (newline == 0) 165 { 166 printf("\n"); 167 newline = sum - 1; 168 sum = 0; 169 } 170 else 171 { 172 --newline; 173 } 174 } 175 if (IfEmpty(L) == FALSE) 176 { 177 Dequeue_L(L, p); 178 ergodic(p, L, newline, sum); 179 } 180 return OK; 181 } 182 /*** 183 * @name Status print(BTree T) 184 * @description 层次遍历并分层输出B树 185 * @return 成功返回OK 186 * @notice 187 ***/ 188 Status print(BTree T) 189 { 190 LinkList L; 191 if (T == NULL) 192 { 193 printf("[ ]\n"); 194 return OK; 195 } 196 InitQueue_L(L); 197 ergodic(T, L, 0, 0); 198 DestroyQueue(L); 199 return OK; 200 } 201 202 /*** 203 * @name Status findMax(BTree T, BTree &p,int ans) 204 * @description 寻找最大关键字的结点,T为要寻找的树，p为返回的节点,ans为第几个 205 * @return 成功返回OK,否则返回ERROR 206 * @notice 207 ***/ 208 Status findMax(BTree T, BTree &p, int &ans) 209 { 210 if (T == NULL) 211 return ERROR; 212 p = T; 213 while (p->ptr[p->keynum] != NULL) 214 { 215 p = p->ptr[p->keynum]; 216 } 217 ans = p->keynum; 218 return OK; 219 } 220 /*** 221 * @name Status findMin(BTree T, BTree &p,int ans) 222 * @description 寻找最小关键字的结点,T为要寻找的树，p为返回的节点,ans为第几个 223 * @return 成功返回OK,否则返回ERROR 224 * @notice 225 ***/ 226 /*** 227 * @name Status findBTree(BTree T, BTree &p, int &ans, KeyType k) 228 * @description 寻找 ,T为要寻找的树，p为返回的节点，ans为第几个元素，k为要找的值 229 * @return 成功返回OK,否则返回ERROR 230 * @notice 231 ***/ 232 Status findBTree(BTree T, BTree &p, int &ans, KeyType k) 233 { 234 BTree q; 235 int index = 1; 236 KeyType keynow; 237 if (T == NULL) 238 return ERROR; 239 q = T; 240 keynow = T->key[1]; 241 while (q != NULL) //深度的遍历 242 { 243 index = 1; 244 keynow = q->key[index]; 245 while (index <= q->keynum) //节点内对各真值进行遍历 246 { 247 if (k == keynow) //找到元素 248 { 249 p = q; 250 ans = index; 251 return TRUE; 252 } 253 if (k > keynow) 254 { 255 if (index == q->keynum) 256 { 257 if (q->ptr[index] == NULL) 258 { 259 p = q; 260 ans = q->keynum + 1; 261 return FALSE; 262 } 263 q = q->ptr[index]; 264 break; 265 } 266 ++index; 267 keynow = q->key[index]; 268 continue; 269 } 270 if (k < keynow) 271 { 272 if (q->ptr[index - 1] == NULL) 273 { 274 p = q; 275 ans = index; 276 return FALSE; 277 } 278 q = q->ptr[index - 1]; 279 break; 280 } 281 } 282 } 283 284 return ERROR; 285 } 286 /*** 287 * @name Status renewParent(BTree p) 288 * @description 告诉孩子们亲身爸爸是谁 289 * @return 成功返回OK,否则返回ERROR 290 * @notice 291 ***/ 292 Status renewParent(BTree p) 293 { 294 int index; 295 if (p == NULL) return ERROR; 296 for (index = 0;index <= p->keynum;++index) 297 { 298 if (p->ptr[index] != NULL) 299 { 300 p->ptr[index]->parent = p; 301 renewParent(p->ptr[index]); 302 } 303 } 304 return OK; 305 } 306 /*** 307 * @name int whichSon(BTree T) 308 * @description 找出是父亲的第几个孩子 309 * @return 成功返回第几个孩子,否则返回-1 310 * @notice 311 ***/ 312 int whichSon(BTree T) 313 { 314 int index = -1; 315 if (T == NULL) return -1; 316 for (index = 0;index <= T->parent->keynum;++index) //找出是父亲的第几个孩子 317 { 318 if (T->parent->ptr[index] == T) return index; 319 } 320 return -1; 321 } 322 /*** 323 * @name status splitBTree(BTree T) 324 * @description 递归实现分裂节点操作 325 * @return 成功返回OK,否则返回ERROR 326 * @notice 327 ***/ 328 Status splitBTree(BTree T) //此时分裂的节点一定会是超出最大值的。 329 { 330 BTree t1, t2; 331 int index, index_1; 332 if (T->parent == NULL) 333 { 334 t1 = (BTree)malloc(BTLEN); 335 if (NULL == t1) return OVERFLOW; 336 t2 = (BTree)malloc(BTLEN); 337 if (NULL == t2) return OVERFLOW; 338 339 t1->keynum = m / 2; 340 t2->keynum = m - (m / 2) - 1; 341 t1->parent = T; 342 t2->parent = T; 343 for (index = 0;index <= m; ++index) //先全部初始化 344 { 345 t1->ptr[index] = NULL; 346 t1->key[index] = 0; 347 t2->ptr[index] = NULL; 348 t2->key[index] = 0; 349 } 350 for (index = 0;index <= m / 2; ++index) //初始化t1 351 { 352 t1->ptr[index] = T->ptr[index]; 353 t1->key[index] = T->key[index]; 354 } 355 t2->ptr[0] = T->ptr[(m / 2) + 1]; 356 for (index = (m / 2) + 2;index <= m; ++index) //初始化t2 357 { 358 t2->ptr[index - ((m / 2) + 1)] = T->ptr[index]; 359 t2->key[index - ((m / 2) + 1)] = T->key[index]; 360 } 361 T->keynum = 1; 362 T->ptr[0] = t1; 363 T->ptr[1] = t2; 364 T->key[1] = T->key[m / 2 + 1]; 365 for (index = 2;index <= m; ++index) //初始化T 366 { 367 T->ptr[index] = NULL; 368 T->key[index] = 0; 369 } 370 return OK; 371 } 372 373 index = whichSon(T); 374 for (index_1 = T->parent->keynum;index_1 > index;--index_1) //腾出父亲的位置 375 { 376 T->parent->ptr[index_1 + 1] = T->parent->ptr[index_1]; 377 T->parent->key[index_1 + 1] = T->parent->key[index_1]; 378 } 379 T->parent->keynum++; 380 T->parent->key[index + 1] = T->key[m / 2 + 1]; 381 t2 = T->parent->ptr[index + 1] = (BTree)malloc(BTLEN); 382 if (NULL == t2) return OVERFLOW; 383 for (index = 0;index <= m; ++index) //先全部初始化 384 { 385 t2->ptr[index] = NULL; 386 t2->key[index] = 0; 387 } 388 t2->keynum = m - (m / 2) - 1; 389 t2->parent = T->parent; 390 t2->ptr[0] = T->ptr[(m / 2) + 1]; 391 for (index = (m / 2) + 2;index <= m; ++index) //初始化t2 392 { 393 t2->ptr[index - ((m / 2) + 1)] = T->ptr[index]; 394 t2->key[index - ((m / 2) + 1)] = T->key[index]; 395 } 396 T->keynum = m / 2; 397 for (index = (m / 2) + 1;index <= m; ++index) //初始化t2 398 { 399 T->ptr[index] = NULL; 400 T->key[index] = 0; 401 } 402 if (T->parent->keynum == m) 403 { 404 splitBTree(T->parent); 405 } 406 return OK; 407 } 408 /*** 409 * @name Status insertBTree(BTree &T, Record e) 410 * @description 插入实现元素的插入 411 * @return 成功返回OK,如果存在则返回FALSE，否则返回ERROR 412 * @notice 413 ***/ 414 Status insertBTree(BTree &T, Record e) 415 { 416 BTree p; 417 int index, temp; 418 Status find_flag; 419 if (NULL == T) 420 { 421 T = (BTree)malloc(BTLEN); 422 if (NULL == T) return OVERFLOW; 423 T->keynum = 1; 424 T->parent = NULL; 425 for (index = 0;index <= m; ++index) 426 { 427 T->ptr[index] = NULL; 428 T->key[index] = 0; 429 } 430 T->key[1] = e.key; 431 return OK; 432 } 433 find_flag = findBTree(T, p, temp, e.key); 434 if (find_flag == TRUE) 435 { 436 return FALSE; 437 } 438 if (find_flag == FALSE) 439 { //不管怎样先直接插入 440 p->keynum++; 441 for (index = p->keynum;index > temp;--index) 442 { 443 p->key[index] = p->key[index - 1]; 444 p->ptr[index] = p->ptr[index - 1]; 445 } 446 p->ptr[temp] = NULL; 447 p->key[temp] = e.key; 448 if (p->keynum == m) //这种情况得分裂 449 { 450 splitBTree(p); 451 } 452 renewParent(T); 453 return OK; 454 } 455 return ERROR; 456 } 457 /*** 458 * @name Status borrowBNode(BTree &T) 459 * @description 递归实现，向兄弟借元素，否则和兄弟合并 460 * @return 成功返回OK,否则返回ERROR 461 * @notice 这种情况应该是T为单元素结点 462 ***/ 463 Status borrowBNode(BTree T) 464 { 465 int mynum, bronum, index; 466 BTree b = NULL, f = NULL; 467 if (T == NULL) return ERROR; 468 f = T->parent; 469 if (f == NULL)//考虑父亲结点不存在的情况 470 { 471 if (T->keynum == 0) 472 { 473 f = T->ptr[0]; 474 if (f == NULL) 475 { 476 free(T); 477 return EMPTY; 478 } 479 for (index = 0;index <= f->keynum;index++) 480 { 481 T->key[index] = f->key[index]; 482 T->ptr[index] = f->ptr[index]; 483 } 484 T->keynum = f->keynum; 485 free(f); 486 renewParent(T); 487 } 488 return OK; 489 } 490 mynum = whichSon(T); 491 if (mynum == 0) 492 bronum = 1; 493 else 494 bronum = mynum - 1; 495 b = f->ptr[bronum]; 496 if (b->keynum == (m + 1) / 2 - 1) //如果兄弟帮不了你了 497 { 498 //那么就和这个兄弟合体 499 if (bronum < mynum) //如果我不是第一个 500 { 501 b->keynum++; 502 b->key[b->keynum] = f->key[mynum]; 503 b->ptr[b->keynum] = T->ptr[0]; 504 for (index = 1;index <= T->keynum;index++) 505 { 506 b->key[index + b->keynum] = T->key[index]; 507 b->ptr[index + b->keynum] = T->ptr[index]; 508 b->keynum++; 509 } 510 free(T); 511 for (index = mynum;index <= f->keynum;index++) 512 { 513 f->key[index] = f->key[index + 1]; 514 f->ptr[index] = f->ptr[index + 1]; 515 } 516 f->keynum--; 517 } 518 else 519 { 520 T->keynum++; 521 T->key[T->keynum] = f->key[bronum]; 522 T->ptr[T->keynum] = b->ptr[0]; 523 for (index = 1;index <= b->keynum;index++) 524 { 525 T->key[index + T->keynum] = b->key[index]; 526 T->ptr[index + T->keynum] = b->ptr[index]; 527 T->keynum++; 528 } 529 free(b); 530 for (index = bronum;index <= f->keynum;index++) 531 { 532 f->key[index] = f->key[index + 1]; 533 f->ptr[index] = f->ptr[index + 1]; 534 } 535 f->keynum--; 536 } 537 renewParent(f); 538 if (f->keynum == (m + 1) / 2 - 2) 539 { 540 //调用借兄弟的函数 541 return borrowBNode(f); 542 } 543 } 544 else//如果兄弟能够帮你 545 { 546 if (bronum < mynum) //如果我不是第一个 547 { 548 for (index = 1;index <= T->keynum;index++) 549 { 550 T->key[index + 1] = T->key[index]; 551 T->ptr[index + 1] = T->ptr[index]; 552 } 553 T->ptr[1] = T->ptr[0]; 554 T->key[1] = f->key[mynum]; 555 T->ptr[0] = b->ptr[b->keynum]; 556 T->keynum++; 557 f->key[mynum] = b->key[b->keynum]; 558 b->key[b->keynum] = 0; 559 b->ptr[b->keynum] = NULL; 560 b->keynum--; 561 562 } 563 else //如果我是第一个 564 { 565 T->keynum++; 566 T->key[T->keynum] = f->key[1]; 567 T->ptr[T->keynum] = b->ptr[0]; 568 f->key[1] = b->key[1]; 569 b->ptr[0] = b->ptr[1]; 570 for (index = 1;index <= b->keynum;index++) 571 { 572 b->key[index] = b->key[index + 1]; 573 b->ptr[index] = b->ptr[index + 1]; 574 } 575 b->keynum--; 576 } 577 } 578 return OK; 579 } 580 581 /*** 582 * @name Status deleteBTreeRecord(BTree &T, Record e) 583 * @description 实现B树元素的删除 584 * @return 成功返回OK,否则返回ERROR 585 * @notice 586 ***/ 587 Status deleteBTreeRecord(BTree &T, Record e) 588 { 589 BTree p, q; 590 int num, temp, index; 591 Status find_flag; 592 if (T == NULL) 593 return ERROR; 594 find_flag = findBTree(T, p, temp, e.key); 595 if (find_flag == FALSE) 596 { 597 return FALSE; 598 } 599 if (find_flag == TRUE) 600 { 601 //deleteBTreeBNode(p,temp); 602 if (p->ptr[temp] == NULL) //如果是叶子节点的话 603 { 604 for (index = temp;index <= p->keynum;++index) 605 { 606 p->key[index] = p->key[index + 1]; 607 p->ptr[index] = p->ptr[index + 1]; 608 } 609 p->keynum--; 610 if (p->keynum == (m + 1) / 2 - 2) 611 { 612 //调用借兄弟的函数 613 if (borrowBNode(p) == EMPTY) T = NULL; 614 else renewParent(T); 615 } 616 return OK; 617 } 618 else //不是叶子结点的话 619 { 620 //遍历 621 findMax(p->ptr[temp - 1], q, num);//返回的q一定会是叶子节点 622 p->key[temp] = q->key[num]; 623 q->key[num] = 0; 624 q->keynum--; 625 if (q->keynum == (m + 1) / 2 - 2) 626 { 627 //调用借兄弟的函数 628 if (borrowBNode(q) == EMPTY) T = NULL; 629 else renewParent(T); 630 } 631 return OK; 632 } 633 return OK; 634 } 635 return ERROR; 636 } 637 /*** 638 * @name Status initBTree(BTree &t) 639 * @description 初始化一个空B树 640 * @return 成功返回OK 641 * @notice 642 ***/ 643 Status initBTree(BTree &t) 644 { 645 t = NULL; 646 return OK; 647 } 648 /*** 649 * @name Status test() 650 * @description 针对数据结构实验做的测试函数 651 * @return 成功返回OK 652 * @notice 653 ***/ 654 Status test() 655 { 656 // 测试代码 657 int n, i; 658 int arr[BTREELENGTH]; 659 BTree a; 660 Record d; 661 srand((unsigned)time(NULL)); 662 n = rand() % BTREELENGTH; 663 //scanf("%d", &n); //可以改为自己输入数据 664 printf("B树的阶为:%d,插入次数为:%d\n", m, n); 665 initBTree(a); 666 for (i = 0;i < n;i++) 667 { 668 d.key = rand() % MAXINT; 669 //scanf("%d", &d.key); //可以改为自己输入数据 670 arr[i] = d.key; 671 if (insertBTree(a, d) == OK) 672 printf("第%d次插入%d:\n", i + 1, d.key); 673 else 674 printf("第%d次插入%d不成功:\n", i + 1, d.key); 675 print(a); 676 } 677 for (i = 0;i < n;i++) 678 { 679 d.key = arr[i]; 680 if (deleteBTreeRecord(a, d) == OK) 681 printf("第%d次删除%d:\n", i + 1, d.key); 682 else 683 printf("第%d次删除%d不成功:\n", i + 1, d.key); 684 print(a); 685 } 686 return OK; 687 688 } 689 /*** 690 主函数 691 ***/ 692 int main() 693 { 694 test(); 695 return 0; 696 }
