[轉]B+樹的結構和實現程式碼

/*******************************************************//* btrees.c */
#include
#include
#include "btrees.h"

btree search(typekey, btree);
btree insert(typekey,btree);
btree delete(typekey,btree);
int height(btree);
int count(btree);
double payload(btree);
btree deltree(btree);

staticvoid InternalInsert(typekey, btree);

staticvoid InsInNode(btree, int);
staticvoid SplitNode(btree, int);
static btree NewRoot(btree);

staticvoid InternalDelete(typekey, btree);
staticvoid JoinNode(btree, int);
staticvoid MoveLeftNode(btree t, int);
staticvoid MoveRightNode(btree t, int);
staticvoid DelFromNode(btree t, int);
static btree FreeRoot(btree);

static btree delall(btree);
staticvoid Error(int,typekey);

int btree_disp; /* 查詢時找到的鍵在節點中的位置 */char* InsValue = NULL; /* 與要插的鍵相對應的值 */staticint flag; /* 節點增減標誌 */staticint btree_level =0; /* 多路樹的高度 */staticint btree_count =0; /* 多路樹的鍵總數 */staticint node_sum =0; /* 多路樹的節點總數 */staticint level; /* 當前訪問的節點所處的高度 */static

btree NewTree; /* 在節點分割的時候指向新建的節點 */static typekey InsKey; /* 要插入的鍵 */

btree search(typekey key, btree t)
{
int i,j,m;
level=btree_level-1;
while (level >=0){
for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));
if (key == t->k){
btree_disp = i;
return t;
}
if (key > t->k) /* i == t->d-1 時有可能出現 */
i++;
t = t->p;
level--;
}
return NULL;
}

btree insert(typekey key, btree t)
{
level=btree_level;
InternalInsert(key, t);
if (flag ==1) /* 根節點滿之後，它被分割成兩個半滿節點 */
t=NewRoot(t); /* 樹的高度增加 */return t;
}

void InternalInsert(typekey key, btree t)
{
int i,j,m;

level--;
if (level <0){ /* 到達了樹的底部: 指出要做的插入 */
NewTree = NULL; /* 這個鍵沒有對應的子樹 */
InsKey = key; /* 導致底層的葉子節點增加鍵值+空子樹對 */
btree_count++;
flag =1; /* 指示上層節點把返回的鍵插入其中 */return;
}
for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));
if (key == t->k) {
Error(1,key); /* 鍵已經在樹中 */
flag =0;
return;
}
if (key > t->k) /* i == t->d-1 時有可能出現 */
i++;
InternalInsert(key, t->p);

if (flag ==0)
return;
/* 有新鍵要插入到當前節點中 */if (t->d <2*M) {/* 當前節點未滿 */
InsInNode(t, i); /* 把鍵值+子樹對插入當前節點中 */
flag =0; /* 指示上層節點沒有需要插入的鍵值+子樹，插入過程結束 */
}
else/* 當前節點已滿，則分割這個頁面並把鍵值+子樹對插入當前節點中 */
SplitNode(t, i); /* 繼續指示上層節點把返回的鍵值+子樹插入其中 */
}

/*
* 把一個鍵和對應的右子樹插入一個節點中
*/void InsInNode(btree t, int d)
{
int i;
/* 把所有大於要插入的鍵值的鍵和對應的右子樹右移 */for(i = t->d; i > d; i--){
t->k = t->k[i-1];
t->v = t->v[i-1];
t->p[i+1] = t->p;
}
/* 插入鍵和右子樹 */
t->k = InsKey;
t->p[i+1] = NewTree;
t->v = InsValue;
t->d++;
}
/*
* 前件是要插入一個鍵和對應的右子樹，並且本節點已經滿
* 導致分割這個節點，插入鍵和對應的右子樹，
* 並向上層返回一個要插入鍵和對應的右子樹
*/void SplitNode(btree t, int d)
{
int i,j;
btree temp;
typekey temp_k;
char*temp_v;
/* 建立新節點 */
temp = (btree)malloc(sizeof(node));
/*
* +---+--------+-----+-----+--------+-----+
* | 0 | ...... | M | M+1 | ...... |2*M-1|
* +---+--------+-----+-----+--------+-----+
* |<- M+1 ->|<- M-1 ->|
*/if (d > M) { /* 要插入當前節點的右半部分 *//* 把從 2*M-1 到 M+1 的 M-1 個鍵值+子樹對轉移到新節點中,
* 並且為要插入的鍵值+子樹空出位置 */for(i=2*M-1,j=M-1; i>=d; i--,j--) {
temp->k[j] = t->k;
temp->v[j] = t->v;
temp->p[j+1] = t->p[i+1];
}
for(i=d-1,j=d-M-2; j>=0; i--,j--) {
temp->k[j] = t->k;
temp->v[j] = t->v;
temp->p[j+1] = t->p[i+1];
}
/* 把節點的最右子樹轉移成新節點的最左子樹 */
temp->p[0] = t->p[M+1];
/* 在新節點中插入鍵和右子樹 */
temp->k[d-M-1] = InsKey;
temp->p[d-M] = NewTree;
temp->v[d-M-1] = InsValue;
/* 設定要插入上層節點的鍵和值 */
InsKey = t->k[M];
InsValue = t->v[M];

}
else { /* d <= M *//* 把從 2*M-1 到 M 的 M 個鍵值+子樹對轉移到新節點中 */for(i=2*M-1,j=M-1; j>=0; i--,j--) {
temp->k[j] = t->k;
temp->v[j] = t->v;
temp->p[j+1] = t->p[i+1];
}
if (d == M) /* 要插入當前節點的正中間 *//* 把要插入的子樹作為新節點的最左子樹 */
temp->p[0] = NewTree;
/* 直接把要插入的鍵和值返回給上層節點 */else { /* (d /* 把節點當前的最右子樹轉移成新節點的最左子樹 */
temp->p[0] = t->p[M];
/* 儲存要插入上層節點的鍵和值 */
temp_k = t->k[M-1];
temp_v = t->v[M-1];
/* 把所有大於要插入的鍵值的鍵和對應的右子樹右移 */for(i=M-1; i>d; i--) {
t->k = t->k[i-1];
t->v = t->v[i-1];
t->p[i+1] = t->p;
}
/* 在節點中插入鍵和右子樹 */
t->k[d] = InsKey;
t->p[d+1] = NewTree;
t->v[d] = InsValue;
/* 設定要插入上層節點的鍵和值 */
InsKey = temp_k;
InsValue = temp_v;
}
}
t->d =M;
temp->d = M;
NewTree = temp;
node_sum++;
}

btree delete(typekey key, btree t)
{
level=btree_level;
InternalDelete(key, t);
if (t->d ==0)
/* 根節點的子節點合併導致根節點鍵的數目隨之減少，
* 當根節點中沒有鍵的時候，只有它的最左子樹可能非空 */
t=FreeRoot(t);
return t;
}

void InternalDelete(typekey key, btree t)
{
int i,j,m;
btree l,r;
int lvl;

level--;
if (level <0) {
Error(0,key); /* 在整個樹中未找到要刪除的鍵 */
flag =0;
return;
}
for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));
if (key == t->k) { /* 找到要刪除的鍵 */if (t->v != NULL)
free(t->v); /* 釋放這個節點包含的值 */if (level ==0) { /* 有子樹為空則這個鍵位於葉子節點 */
DelFromNode(t,i);
btree_count--;
flag =1;
/* 指示上層節點本子樹的鍵數量減少 */return;
} else { /* 這個鍵位於非葉節點 */
lvl = level-1;
/* 找到前驅節點 */
r = t->p;
while (lvl >0) {
r = r->p[r->d];
lvl--;
}
t->k=r->k[r->d-1];
t->v=r->v[r->d-1];
r->v[r->d-1]=NULL;
key = r->k[r->d-1];
}
}
elseif (key > t->k) /* i == t->d-1 時有可能出現 */
i++;
InternalDelete(key,t->p);
/* 調整平衡 */if (flag ==0)
return;
if (t->p->d < M) {
if (i == t->d) /* 在最右子樹中發生了刪除 */
i--; /* 調整最右鍵的左右子樹平衡 */
l = t->p;
r = t->p[i+1];
if (r->d > M)
MoveLeftNode(t,i);
elseif(l->d > M)
MoveRightNode(t,i);
else {
JoinNode(t,i);
/* 繼續指示上層節點本子樹的鍵數量減少 */return;
}
flag =0;
/* 指示上層節點本子樹的鍵數量沒有減少，刪除過程結束 */
}
}

/*
* 合併一個節點的某個鍵對應的兩個子樹
*/void JoinNode(btree t, int d)
{
btree l,r;
int i,j;
l = t->p[d];
r = t->p[d+1];

/* 把這個鍵下移到它的左子樹 */
l->k[l->d] = t->k[d];
l->v[l->d] = t->v[d];
/* 把右子樹中的所有鍵值和子樹轉移到左子樹 */for (j=r->d-1,i=l->d+r->d; j >=0 ; j--,i--) {
l->k = r->k[j];
l->v = r->v[j];
l->p = r->p[j];
}
l->p[l->d+r->d+1] = r->p[r->d];
l->d += r->d+1;
/* 釋放右子樹的節點 */
free(r);
/* 把這個鍵右邊的鍵和對應的右子樹左移 */for (i=d; i < t->d-1; i++) {
t->k = t->k[i+1];
t->v = t->v[i+1];
t->p[i+1] = t->p[i+2];
}
t->d--;
node_sum--;
}
/*
* 從一個鍵的右子樹向左子樹轉移一些鍵，使兩個子樹平衡
*/void MoveLeftNode(btree t, int d)
{
btree l,r;
int m; /* 應轉移的鍵的數目 */int i,j;
l = t->p[d];
r = t->p[d+1];
m = (r->d - l->d)/2;

/* 把這個鍵下移到它的左子樹 */
l->k[l->d] = t->k[d];
l->v[l->d] = t->v[d];
/* 把右子樹的最左子樹轉移成左子樹的最右子樹
* 從右子樹向左子樹移動 m-1 個鍵+子樹對 */for (j=m-2,i=l->d+m-1; j >=0; j--,i--) {
l->k = r->k[j];
l->v = r->v[j];
l->p = r->p[j];
}
l->p[l->d+m] = r->p[m-1];
/* 把右子樹的最左鍵提升到這個鍵的位置上 */
t->k[d] = r->k[m-1];
t->v[d] = r->v[m-1];
/* 把右子樹中的所有鍵值和子樹左移 m 個位置 */
r->p[0] = r->p[m];
for (i=0; id-m; i++) {
r->k = r->k[i+m];
r->v = r->v[i+m];
r->p = r->p[i+m];
}
r->p[r->d-m] = r->p[r->d];
l->d+=m;
r->d-=m;
}
/*
* 從一個鍵的左子樹向右子樹轉移一些鍵，使兩個子樹平衡
*/void MoveRightNode(btree t, int d)
{
btree l,r;
int m; /* 應轉移的鍵的數目 */int i,j;
l = t->p[d];
r = t->p[d+1];

m = (l->d - r->d)/2;
/* 把右子樹中的所有鍵值和子樹右移 m 個位置 */
r->p[r->d+m]=r->p[r->d];
for (i=r->d-1; i>=0; i--) {
r->k[i+m] = r->k;
r->v[i+m] = r->v;
r->p[i+m] = r->p;
}
/* 把這個鍵下移到它的右子樹 */
r->

[轉]B+樹的結構和實現程式碼

[轉]B+樹的結構和實現程式碼

MySQL B+樹索引和哈希索引的區別（轉 JD二面）

B樹插入刪除圖文程式碼實現 golang實現

資料庫為什麼要用B+樹結構--MySQL索引結構的實現

資料結構與演算法——B樹的C++實現

【資料結構】平衡搜尋樹之---B樹的演算法實現

【資料結構】樹（四）：B樹（C++實現）

二叉樹的儲存結構和實現

《MySQL實戰45講》學習筆記3——InnoDB為什麼採用B+樹結構實現索引

看得見的資料結構Android版之二分搜尋樹結構的實現

程式設計基礎79 給定二叉排序樹結構和陣列求整棵樹

資料結構之樹結構的實現--二叉樹鏈式結構(C語言)

二叉樹基礎操作，前中後序遍歷，求二叉樹高度，二叉搜尋樹（二叉排序樹）Java實現程式碼集合

雜湊儲存、B樹儲存和LSM樹儲存引擎

B樹（或B-樹）和B+樹和B*樹（不看後悔，一看必懂）

B+樹的Java實現

圖解B+樹並和B-樹特點對比總結

B+樹C語言實現

MySQL B+樹索引和哈希索引的區別

B-樹的C++實現

[轉]B+樹的結構和實現程式碼

相關推薦