資料結構 關於B樹說明及插入和分裂

yuntui發表於2016-11-03
原文網址 : http://blog.itpub.net/30633755/viewspace-2127705/
資料結構
注意：本文是我學習的一點總結，具體的程式碼並沒有經過除錯，是通過演算法導論B樹中的描述寫成，但是增加了關於資料的連結串列，而不是
如演算法導論中的一個陣列，留於此用於以後的繼續深入學習。

B樹的定義和特點：
B樹的階實際上就是指向子樹的最大指標個數
比如2-3樹階為3,2-3-4樹階為4
B樹已經不是常規的樹結構，多用於檔案系統管理，每個節點可以有多個指向
孩子的指標，特點如下：
1、根要麼為空樹，要麼至少有2個子樹
2、假設M階的B樹，n個指向子樹的指標
   則：
   Ceil(M/2)<=n<=M
   n-1個關鍵字
   則
   ceil(M/2)-1<=n-1<=M-1
3、所有葉子結點在同一層次
4、設Pn為指標，Kn為關鍵字
  KEYS=n P0K1P1K2P2K3P3..........
  P0指向子樹的所有值均小於K1
  P1指向子樹的所有值均大於K1
5、有K1<K2<K3<K4的順序
如下就是一顆5階4關鍵字的B樹




B樹的優勢(可以說也是B+樹的優勢)：
由於在一些應用中比如資料庫應用中，資料量肯能非常大，在這種情況一棵完全依賴記憶體的
樹就不可取了，首先資料量過大使用AVL樹或者紅黑樹得到的深度難以想象，二來不可能有
那麼多的記憶體用於存放整個資料，實際上在資料庫中往往是通過一個指標(並非記憶體中的指標)，
這個指標實際上是資料塊的塊號，如果我們只將B樹的根結點快取到記憶體中，那麼我們根據
B樹的查詢原則將路徑中的資料塊存放到快取，那麼不僅效能大大提高，同時也減少了記憶體
的使用，一般物理磁碟的讀取速度為毫秒級別，而記憶體矽儲存的讀取速度為納秒級別，基本
上是5個數量級的差別。同時為了更大發揮磁碟讀取的效率，一般來講在資料庫中B+樹的根結
點為1個block.


B樹的插入分裂：

1、如果葉子結點有足夠的空間如果按照嚴格的定義就是

   ciel(M/2)-1<=n-1<M-1  注意是小於M-1這樣肯定小於

   最大允許的關鍵字，那麼就在找到的葉子結點進行插入

2、如果葉子結點關鍵字大於M-1，而雙親結點空間<M-1，則

   分裂葉子結點，同時中間元素上移到雙親結點(我們以奇數

   關鍵字為例)的相應位置,這樣的移動的依據來自於

   第四點：

  KEYS=n P0K1P1K2P2K3P3..........

  P0指向子樹的所有值均小於K1

  P1指向子樹的所有值均大於K1

  B樹實際上也是一個有序樹，按照這個規則上移後必然也滿足

  上面的規則，因為在一個節點中資料是有序排列我們設定是

  升序。

 

3、如果雙親結點也處於M-1狀態，那麼雙親結點也需要分裂，其規則

   如葉子結點一致，關於這一點演示如下：

考慮如下樹(5階,4關鍵字，注意5階關子健最少2個最多4個)


插入55：

 

4、如果根結點也處於M-1狀態，上面的情況就出現了B樹索引高度加1的情況

   演示如下：

   考慮如下樹(5階,4關鍵字)插入84：

最後節點64分裂開來，樹的高度由3變為了4 



演算法導論中的說明：
在演算法導論中對b樹的分裂做了一定的改動，也就是說在進行資料查詢的時候
路過的結點，如果發現出現了等於最大關鍵的節點就進行分裂，這樣雖然增加
了分裂的可能性，但是並不會增加太多因為增加的分裂次數只是一個常量而已
是一種方便的可行的程式設計方式。
並且進行了義一箇中間量用於標示節點指標的中間位置，如果設定這個中間為
_BTREE_POINTER_M_,那麼指標的個數最大始終為2*_BTREE_POINTER_M_為偶數，
而關鍵字個數始終為2*_BTREE_POINTER_M_-1為一個奇數，如果定義
BTREE_POINTER_M_=2 那麼就是2-3-4樹，這樣對程式設計也帶來了一定的方便，我們
也採用這種方式。而2-3樹這樣的定義是不能實現的。

程式碼（問題很多沒除錯過，演算法導論描述編寫而成）,這部分可以參考演算法導論關於
B樹的描述

點選(此處)摺疊或開啟

  1. head.h
  2. #define _BTREE_POINTER_M_ 2
  3. #define _BTREE_POINTER_ (_BTREE_POINTER_M_ * 2) //2-3-4tree。
  4. #define _BTREE_KEYS_ (_BTREE_POINTER_M_ * 2-1)
  5. #define bool int
  6. #define true 1
  7. #define false 0
  8. #define ALLOCBNODE (BTNodeP)calloc(1,sizeof(BTNode))
  9. #define SIZENODE sizeof(DULNODE)
  10. #define SIZELISTHEAD sizeof(LISTHEAD)
  11. #define SIZEBTHead sizeof(BTHead)


  14. typedef struct dulnode //node type of btree data
  15. {

  17.         int data; //example
  18.         struct dulnode *prior;
  19.         struct dulnode *next;
  20. } DULNODE,*DULNODEP;

  22. typedef struct listhead ///node type of btree data header
  23. {

  25.         DULNODEP head;
  26.         DULNODEP last;
  27.         DULNODEP current;
  28.         int length;
  29. } LISTHEAD,*LISTHEADP;

  31. typedef struct BTNode{
  32.         int keynum; // 結點中關鍵字的個數，keynum <= _BTREE_KEYS_
  33.         LISTHEADP keyhder; // 資料連結串列實現的頭指標
  34.         struct BTNode* child[_BTREE_POINTER_]; // 孩子指標
  35.         bool isLeaf; // 是否是葉子節點的標誌
  36.         int nodenum; // 節點計數
  37. }BTNode,*BTNodeP;


  40. typedef struct BTHead{
  41.         BTNodeP root_node; //指向B樹的根結點
  42.         int max_node_num; // 當前節點個數計數
  43.            int btree_level; //B樹的層次
  44. }BTHead,*BTHeadP;


點選(此處)摺疊或開啟

  1. #include<stdio.h>
  2. #inlcude<stdlib.h>


  5. //chain fun

  7. bool initlist(LISTHEADP* p)
  8. {
  9.         *p = (LISTHEADP)malloc(SIZELISTHEAD);
  10.         if(!*p)
  11.         {
  12.                 return false;
  13.         }
  14.         else
  15.         {
  16.                 memset(*p,0,SIZELISTHEAD);
  17.                 (*p)->head = NULL;
  18.                 (*p)->last = NULL;
  19.                 (*p)->current = NULL;
  20.                 (*p)->length = 0;
  21.                 return true;
  22.         }
  23. }

  25. //inslast insert one node at last postion

  27. void inslast(LISTHEADP h,DULNODEP s)
  28. {
  29.         if(!(h->head)) //list is empty or not
  30.         {
  31.                 h->head = s;
  32.                 h->last = s;
  33.                 h->current = s;
  34.                 h->length++;
  35.         }
  36.         else
  37.         {
  38.                 h->last->next = s;
  39.                 s->prior = h->last;
  40.                 h->last = s;
  41.                 h->current = s;
  42.                 h->length++;
  43.         }
  44. }

  46. void delfirst(LISTHEADP h) //delete first node current_point to next node
  47. {
  48.         DULNODEP p;
  49.         if(!(h->head))
  50.         {
  51.                 printf("error(1):delfirst() error list have no node!\n");
  52.                 exit(1);
  53.         }
  54.         else if(!(h->head->next)) //only one node
  55.         {
  56.                 free(h->head);
  57.                 h->head = NULL;
  58.                 h->current = NULL;
  59.                 h->last = NULL;
  60.                 h->length--;
  61.         }
  62.         else
  63.         {
  64.                 p = h->head ;
  65.                 h->head->next->prior = NULL;
  66.                 h->head = h->head->next;
  67.                 h->current = h->head;
  68.                 h->length--;
  69.                 free(p);
  70.         }
  71. }

  73. bool makenode(int datavalue,DULNODEP* p)
  74. {
  75.         *p = (DULNODEP) malloc (SIZENODE);
  76.         if(!(*p))
  77.         {
  78.                 return false;
  79.         }
  80.         else
  81.         {
  82.                 memset(*p,0,SIZENODE);
  83.                 (*p)->data = datavalue;
  84.                 (*p)->next = NULL;
  85.                 (*p)->prior = NULL;
  86.                 return true;
  87.         }
  88. }

  90. static DULNODEP getelemp(const LISTHEADP h,int postion)
  91. {
  92.         int i=0;
  93.         DULNODEP p;
  94.         if(postion > h->length || postion ==0 )
  95.         {
  96.                 printf("error(2):getelemp() postion large than lenth or poastion = 0\n");
  97.                 exit(2);
  98.         }
  99.         p = h->head;

  101.         while(i<postion-1)
  102.         {
  103.                 i++;
  104.                 p = p->next;
  105.         }
  106.         return p;
  107. }

  109. void dellast(LISTHEADP h) //delete last node current_point to prior node
  110. {
  111.         DULNODEP p;
  112.         if(!(h->head))
  113.         {
  114.                 printf("error(1):delfirst() error list have no node!\n");
  115.                 exit(1);
  116.         }
  117.         else if(!(h->head->next)) //only one node
  118.         {
  119.                 free(h->head);
  120.                 h->head = NULL;
  121.                 h->current = NULL;
  122.                 h->last = NULL;
  123.                 h->length--;
  124.         }
  125.         else
  126.         {
  127.                 p = h->last ;
  128.                 h->last->prior->next = NULL;
  129.                 h->last = p->prior;
  130.                 h->current = p->prior;
  131.                 h->length--;
  132.                 free(p);
  133.         }
  134. }


  137. static int findpos(LISTHEADP h,int k,int i)
  138. {
  139.     DULNODEP p=NULL;

  141.     if(h->length == 0)
  142.         {return 1;}
  143.     else
  144.         {
  145.             p = h->last;
  146.             while(i>=1 && p->data > k) // exp : i = 1 one key if k<data frist insert else k>data return 2
  147.                 {
  148.              if(i==1)
  149.                  {
  150.                      return i;
  151.                  }
  152.                  p = p->prior;
  153.                  i--;
  154.                 }
  155.             return i+1; // i+1=2 is insert after node 1
  156.         }
  157. }


  160. //addnode add one node after give postion
  161. void addnode(DULNODEP inode,int postion,LISTHEADP h) //insert one elem after postion
  162. {
  163.         DULNODEP p;
  164.         p = getelemp(h,postion);
  165.         if(!p->next) //last node?
  166.         {
  167.                 p->next = inode;
  168.                 inode->prior = p;
  169.                 inode->next = NULL;
  170.                 h->last = inode;
  171.                 h->current = inode;
  172.         }
  173.         else
  174.         {
  175.                 inode->prior = p;
  176.                 inode->next = p->next;
  177.                 p->next->prior = inode;
  178.                 p->next = inode;
  179.                 h->current = inode;
  180.         }
  181.         h->length++;
  182. }

  184. //insfirst insert one node at first postion

  186. void insfirst(LISTHEADP h,DULNODEP s)
  187. {
  188.         if(!(h->head)) //list is empty or not
  189.         {
  190.                 h->head = s;
  191.                 h->last = s;
  192.                 h->current = s;
  193.                 h->length++;
  194.         }
  195.         else
  196.         {
  197.                 h->head->prior = s;
  198.                 s ->next = h->head;
  199.                 h->head = s;
  200.                 h->current = s;
  201.                 h->length++;

  203.         }

  205. }


  208. //btree fun

  210. bool B_Tree_Inital(BTHeadP* p)
  211. {
  212.         *p = (BTHeadP)malloc(SIZEBTHead);
  213.         if(!*p)
  214.         {
  215.                 return false;
  216.         }
  217.         else
  218.         {
  219.                 memset(*p,0,SIZEBTHead);
  220.                 (*p)->root_node = NULL;
  221.                 (*p)->max_node_num = 0;
  222.                 (*p)->btree_level = 0;
  223.                 return true;
  224.         }
  225. }


  228. void B_Tree_Create(BTNodeP* root,BTHeadP* p)
  229. {
  230.     BTNodeP x = NULL;
  231.     if(!(x = ALLOCBNODE))
  232.         {
  233.             printf("B_Tree_Create error mem error(10)\n");
  234.             exit(10);
  235.         }
  236.     (*root) = x;
  237.     (*p)->root_node = (*root);//head pointer is root
  238.     (*p)->max_node_num++;
  239.     (*p)->btree_level++;
  240.     (x)->isLeaf = true;
  241.     (x)->keynum = 0;
  242.     (x)->nodenum = (*p)->max_node_num;
  243.     if(!(initlist(&(x->keyhder)));
  244.         {
  245.             printf("B_Tree_Create error mem error(11)\n");
  246.             exit(11);
  247.         }
  248.         
  249. }

  251. void B_Tree_Split(BTNodeP* x,int i,BTNodeP* y,BTHeadP* p) //X是上層結點，y是X的一個滿的子節點，i為y中間元素上浮到x中的位置
  252. {
  253.     BTNodeP z = NULL;
  254.     DULNODEP zcnode = NULL; //btree node z's chain node pointer;
  255.     DULNODEP yfnode = NULL; //used find any node pointer;
  256.     int j=1;
  257.     if(!(z = ALLOCBNODE))
  258.         {
  259.             printf("B_Tree_Split error mem error(12)\n");
  260.             exit(12);
  261.         }
  262.     (*p)->max_node_num++;
  263.     z->isLeaf = (*y)->isLeaf;
  264.     z->keynum = _BTREE_POINTER_M_ - 1;
  265.     z->nodenum = (*p)->max_node_num++;
  266.     if(!(initlist(&(z->keyhder)));
  267.         {
  268.             printf("B_Tree_Split error mem error(13)\n");
  269.             exit(13);
  270.         }
  271.     yfnode = getelemp((*y)->keyhder,_BTREE_POINTER_M_+1);
  272.     
  273.     for(j=1;j<=_BTREE_POINTER_M_-1;j++) //z first half key = y last half key this is very import
  274.     /*
  275.          --x--
  276.         --y-- --z--
  277.     */
  278.         {
  279.             makenode(yfnode->data,&zcnode);
  280.             inslast(z->keyhder,zcnode);
  281.             yfnode = yfnode->next;        
  282.         }
  283.     for(j=1;j<=_BTREE_POINTER_M_-1;j++)//delete y last half key beacuase the key is give to z
  284.         {
  285.             dellast((*y)->keyhder);
  286.         }
  287.     if(!((*y)->isLeaf)) // if node y is not leaf node,child pointer must change ,give half pointer to z ,but total pointer not change
  288.         {
  289.             for(j=1;j<=_BTREE_POINTER_M_;j++)
  290.                 {
  291.                     z->child[j-1] = (*y)->child[j-1+_BTREE_POINTER_M_];
  292.                     (*y)->child[j-1+_BTREE_POINTER_M_] = NULL;
  293.                 }
  294.         }
  295.     (*y)->keynum = _BTREE_POINTER_M_ - 1; //key change
  296.     for(j=(*x)->keynum+1;j>=i+1;j-- ) // 0 1 1 <insert new i=2 is before 2> 2 2 3 3 4 4 --> 0 1 1 new2 new2 3 3 4 4 5 5 i now is before i
  297.         {
  298.             (*x)->child[j] = (*x)->child[j-1];
  299.         }
  300.     (*x)->child[i] = z;

  302.     //find y last data is split data,use yfnode to store
  303.     makenode((*y)->keyhder->last->data,&yfnode);
  304.     //if sucess delete last y data
  305.     dellast((*y)->keyhder) ;
  306.     
  307.     if(i == 1) //move key value
  308.         {
  309.             insfirst((*x)->keyhder,yfnode);
  310.         }
  311.     else
  312.         {
  313.             addnode(yfnode,i-1,(*x)->keyhder);
  314.         }
  315.     (*x)->keynum ++;
  316.     return yfnode->data;
  317.     
  318. }

  320. void B_Tree_Insert_Nofull(BTNodeP* x,int k,BTHeadP* p)
  321. {
  322.     int i ;
  323.     int pos;
  324.     int dataret;
  325.     DULNODEP np = NULL;
  326.     i = (*x)->keynum;
  327.     makenode(k,&np);
  328.     
  329.     if((*x)->isLeaf) //if the x is leaf node ?
  330.         {
  331.             pos=findpos((*x)->keyhder,k,i);
  332.             if(pos == 1)
  333.                 {
  334.                  insfirst((*x)->keyhder,np);// pos == 1 insert at first
  335.                 }
  336.             else
  337.                 {
  338.                     addnode(np,pos-1,(*x)->keyhder); //addnode is insert after pos so pos-1
  339.                 }
  340.             (*x)->keynum++
  341.         }
  342.     else
  343.         {
  344.             pos=findpos((*x)->keyhder,k,i); //not leaf node find leaf node
  345.             if(((*x)->child)[pos-1]->keynum == _BTREE_KEYS_ ) // is child leaf node is full split it
  346.                 {
  347.                 
  348.                     dataret=B_Tree_Split(x,pos,&(((*x)->child)[pos-1]),p); //key real insert pos
  349.                     if( k > dataret) //split sucess if k> B_TREE_SPLIS RETURN SPLIT DATA
  350.                         {
  351.                             pos=pos+1;
  352.                         }
  353.                 }
  354.             B_Tree_Insert_Nofull(&(((*x)->child)[pos-1]),k); //key pos is 1 2 3 4 5......pointer pos is 0 1 2 3 4....so pos-1            
  355.         }
  356. }    


  359. void B_Tree_Insert(BTHeadP* p,int k) //k is value to insert ,BtheadP has a pointer to b_tree_root
  360. {
  361.     BTNodeP r = (*p)->root_node;
  362.     BTNodeP s = NULL;
  363.     if(r->keynum = _BTREE_KEYS_)
  364.         {
  365.             if(!(s = ALLOCBNODE))// new root node
  366.                  {
  367.              printf("B_Tree_Insert error mem error(14)\n");
  368.              exit(14);
  369.                   }
  370.             (*p)->max_node_num++;
  371.             (*p)->root_node = s;
  372.             (*p)->btree_level++;
  373.             s->isLeaf = FALSE;
  374.             s->keynum = 0;
  375.             s->child[0] = r;
  376.             s->nodenum = (*p)->max_node_num;    
  377.             if(!(initlist(&(s->keyhder)));
  378.          {
  379.              printf("B_Tree_Insert error mem error(15)\n");
  380.              exit(15);
  381.          }
  382.              B_Tree_Split(&s,1,&r,&p);
  383.              B_Tree_Insert_Nofull(&s,k,p);            
  384.         }
  385.     else
  386.         {
  387.             B_Tree_Insert_Nofull(&r,k,p);        
  388.         }
  389. }



關於B樹的刪除會涉及到更多的複雜的方面，比如普通刪除，比如節點融合，B樹高度的
降低等，我沒有仔細的學習和研究。

可見B樹B+樹這種資料結構還是比較負載，如果加上很多很多的其他的連結串列或者資料結構
那麼編寫程式的難度非常大，我們使用資料庫的DBA們應該為資料庫軟體的開發者們心存
敬畏，他們是天才的程式設計師。

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/7728585/viewspace-2126929/，如需轉載，請註明出處，否則將追究法律責任。

相關文章