B+树和B-树回顾

B树：二叉搜索树

性质：

1.所有非叶子结点至多拥有两个儿子（Left和Right）；
2.所有结点存储一个关键字；
3.非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树；

//往二叉查找树中插入结点  
//插入的话，可能要改变根结点的地址，所以传的是二级指针  
void inseart(PNode * root,KeyType key)  
{  
    //初始化插入结点  
    PNode p=(PNode)malloc(sizeof(Node));  
    p->key=key;  
    p->left=p->right=p->parent=NULL;  
    //空树时，直接作为根结点  
    if((*root)==NULL){  
        *root=p;  
        return;  
    }  
    //插入到当前结点（*root）的左孩子  
    if((*root)->left == NULL && (*root)->key > key){  
        p->parent=(*root);  
        (*root)->left=p;  
        return;  
    }  
    //插入到当前结点（*root）的右孩子  
    if((*root)->right == NULL && (*root)->key < key){  
        p->parent=(*root);  
        (*root)->right=p;  
        return;  
    }  
    if((*root)->key > key)  
        inseart(&(*root)->left,key);  
    else if((*root)->key < key)  
        inseart(&(*root)->right,key);  
    else  
        return;  
}  
  
//查找元素,找到返回关键字的结点指针，没找到返回NULL  
PNode search(PNode root,KeyType key)  
{  
    if(root == NULL)  
        return NULL;  
    if(key > root->key) //查找右子树  
        return search(root->right,key);  
    else if(key < root->key) //查找左子树  
        return search(root->left,key);  
    else  
        return root;  
}  
  
//查找最小关键字,空树时返回NULL  
PNode searchMin(PNode root)  
{  
    if(root == NULL)  
        return NULL;  
    if(root->left == NULL)  
        return root;  
    else  //一直往左孩子找，直到没有左孩子的结点  
        return searchMin(root->left);  
}  
  
//查找最大关键字,空树时返回NULL  
PNode searchMax(PNode root)  
{  
    if(root == NULL)  
        return NULL;  
    if(root->right == NULL)  
        return root;  
    else  //一直往右孩子找，直到没有右孩子的结点  
        return searchMax(root->right);  
}  
  
//查找某个结点的前驱  
PNode searchPredecessor(PNode p)  
{  
    //空树  
    if(p==NULL)  
        return p;  
    //有左子树、左子树中最大的那个  
    if(p->left)  
        return searchMax(p->left);  
    //无左子树,查找某个结点的右子树遍历完了  
    else{  
        if(p->parent == NULL)  
            return NULL;  
        //向上寻找前驱  
        while(p){  
            if(p->parent->right == p)  
                break;  
            p=p->parent;  
        }  
        return p->parent;  
    }  
}  
  
//查找某个结点的后继  
PNode searchSuccessor(PNode p)  
{  
    //空树  
    if(p==NULL)  
        return p;  
    //有右子树、右子树中最小的那个  
    if(p->right)  
        return searchMin(p->right);  
    //无右子树,查找某个结点的左子树遍历完了  
    else{  
        if(p->parent == NULL)  
            return NULL;  
        //向上寻找后继  
        while(p){  
            if(p->parent->left == p)  
                break;  
            p=p->parent;  
        }  
        return p->parent;  
    }  
}  
  
//根据关键字删除某个结点,删除成功返回1,否则返回0  
//如果把根结点删掉，那么要改变根结点的地址，所以传二级指针  
int deleteNode(PNode* root,KeyType key)  
{  
    PNode q;  
    //查找到要删除的结点  
    PNode p=search(*root,key);  
    KeyType temp;    //暂存后继结点的值  
    //没查到此关键字  
    if(!p)  
        return 0;  
    //1.被删结点是叶子结点，直接删除  
    if(p->left == NULL && p->right == NULL){  
        //只有一个元素，删完之后变成一颗空树  
        if(p->parent == NULL){  
            free(p);  
            (*root)=NULL;  
        }else{  
            //删除的结点是父节点的左孩子  
            if(p->parent->left == p)  
                p->parent->left=NULL;  
            else  //删除的结点是父节点的右孩子  
                p->parent->right=NULL;  
            free(p);  
        }  
    }  
  
    //2.被删结点只有左子树  
    else if(p->left && !(p->right)){  
        p->left->parent=p->parent;  
        //如果删除是父结点，要改变父节点指针  
        if(p->parent == NULL)  
            *root=p->left;  
        //删除的结点是父节点的左孩子  
        else if(p->parent->left == p)  
            p->parent->left=p->left;  
        else //删除的结点是父节点的右孩子  
            p->parent->right=p->left;  
        free(p);  
    }  
    //3.被删结点只有右孩子  
    else if(p->right && !(p->left)){  
        p->right->parent=p->parent;  
        //如果删除是父结点，要改变父节点指针  
        if(p->parent == NULL)  
            *root=p->right;  
        //删除的结点是父节点的左孩子  
        else if(p->parent->left == p)  
            p->parent->left=p->right;  
        else //删除的结点是父节点的右孩子  
            p->parent->right=p->right;  
        free(p);  
    }  
    //4.被删除的结点既有左孩子，又有右孩子  
    //该结点的后继结点肯定无左子树(参考上面查找后继结点函数)  
    //删掉后继结点,后继结点的值代替该结点  
    else{  
        //找到要删除结点的后继  
        q=searchSuccessor(p);  
        temp=q->key;  
        //删除后继结点  
        deleteNode(root,q->key);  
        p->key=temp;  
    }  
    return 1;  
}  
  
//创建一棵二叉查找树  
void create(PNode* root,KeyType *keyArray,int length)  
{  
    int i;  
    //逐个结点插入二叉树中  
    for(i=0;i<length;i++)  
        inseart(root,keyArray[i]);  
}  
  

　　B-树：

1.定义任意非叶子结点最多只有M个儿子；且M>2；
2.根结点的儿子数为[2, M]；
3.除根结点以外的非叶子结点的儿子数为[M/2, M]；
4.每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）
5.非叶子结点的关键字个数=指向儿子的指针个数-1；
6.非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
7.非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树；
8.所有叶子结点位于同一层；

typedef int KeyType ;
#define m 5
typedef struct Node{
int keynum;
struct Node *parent;
KeyType key[m+1];
struct Node *ptr[m+1];
Record *recptr[m+1];
}NodeType;

typedef struct{
NodeType *pt;
int i;
int tag;
}Result;

Result SearchBTree(NodeType *t,KeyType kx)  
{   
      
    p=t;q=NULL;found=FALSE;i=0;   
    while(p&&!found)  
    {   n=p->keynum;i=Search(p,kx);            
        if(i>0&&p->key[i]= =kx) found=TRUE;   
        else {q=p;p=p->ptr[i];}  
    }  
    if(found) return (p,i,1);                 
    else return (q,i,0);                      
}  

B- 树查找算法分析

从查找算法中可以看出， 在B- 树中进行查找包含两种基本操作:

        ( 1) 在B- 树中查找结点；

        ( 2) 在结点中查找关键字。

       由于B- 树通常存储在磁盘上， 则前一查找操作是在磁盘上进行的， 而后一查找操作是在内存中进行的， 即在磁盘上找到指针p 所指结点后， 先将结点中的信息读入内存， 然后再利用顺序查找或折半查找查询等于K 的关键字。显然， 在磁盘上进行一次查找比在内存中进行一次查找的时间消耗多得多.

      因此， 在磁盘上进行查找的次数、即待查找关键字所在结点在B- 树上的层次树， 是决定B树查找效率的首要因素

        那么，对含有n 个关键码的m 阶B-树，最坏情况下达到多深呢？可按二叉平衡树进行类似分析。首先，讨论m 阶B-数各层上的最少结点数。

       由B树定义：B树包含n个关键字。因此有n+1个树叶都在第J+1 层。

    1）第一层为根，至少一个结点，根至少有两个孩子，因此在第二层至少有两个结点。

    2）除根和树叶外，其它结点至少有[m/2]个孩子,因此第三层至少有2*[m/2]个结点,在第四层至少有2*[m/2]2 个结点…

    3）那么在第J+1层至少有2*[m/2]J-1个结点,而J+1层的结点为叶子结点,于是叶子结点的个数n+1。有：

          

        也就是说在n个关键字的B树查找，从根节点到关键字所在的节点所涉及的节点数不超过：

      

　　

B+树

       B+树是B-树的变体，也是一种多路搜索树：

       1.其定义基本与B-树同，除了：

       2.非叶子结点的子树指针与关键字个数相同；

       3.非叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树

（B-树是开区间）；

       5.为所有叶子结点增加一个链指针；

       6.所有关键字都在叶子结点出现；

 

B+的特性：

1.所有关键字都出现在叶子结点的链表中（稠密索引），且链表中的关键字恰好

是有序的；

2.不可能在非叶子结点命中；

3.非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储

（关键字）数据的数据层；

4.更适合文件索引系统；

 

相关详细讲解：http://blog.sina.com.cn/s/blog_4e0c21cc01010itp.html