B 树 B+树

Posted 2021-12-12 Soaring2020

B B+树

一、.多叉树  降层高  【结点数量变少 查找节点次数变少   适合磁盘存取

二、多叉树与B树的关系

1、多叉树没有约束平衡

2、多叉树没有约束每个节点子树的数量

3、遍历数据有规律

4、B树不适合做范围查询

5、B+树将所有的叶子结点做了一个链表所有数据存在叶子节点上

三、一颗M阶B树T，满足以下条件

1、每个节点至多拥有M颗子树。

2、根节点至少拥有两颗子树

3、输了根节点外，其余每个分支节点至少拥有M/2颗子树

4、所有的叶子节点都在同一层上

5有K颗子树的分支节点则存在K-1个关键字，关键字按照递增顺序排序。

6、关键字数量满足ceil（M/2）-1<= M-1.

四、B树

1插入时找到未满

2插到叶子结点

3找到的结点已满（内节点满内分裂，叶子节点满叶子分裂）。

4删除合并

5相邻两棵子树都是M/2-1 ，合并。

6左边子树大于M/2-1，借一个。

7右边子树大于M/2-1，借一个。

#define M  3
typedef int KEY_TYPE;
struct  btree_node
{
    
    struct    btree_node **children;
    KEY_TYPE  *keys;
    int       num;
    int        leaf;
};
struct btree
{
    struct btree_node *root;
    int t;
};
struct btree_node *Btree_create_node(int t,int leaf)
{
    struct btree_node *node = (struct btree_node*)calloc(1,sizeof(struct btree_node));
    if (node== NULL)
    {
        return NULL;
    }
    node->num     = 0;
    node ->keys   = (KEY_TYPE*)calloc(1,(2*t-1)*sizeof(KEY_TYPE));
    node->children= (struct btree_node**)calloc(1,2*t*sizeof(struct btree_node*));
    node->leaf    = leaf;
    return node;
}
struct btree_node *Btree_destroy_node(struct btree_node *node)
{
    if (node)
    {
        if (node->keys)
        {
            free(node->keys);
        }
        if (node->children)
        {
            free(node->children);
        }
        free(node);
    }
}
void btree_split_child(btree *T,btree_node *x,int i)
{
    btree_node *y=x->children[i];
    btree_node *z=Btree_create_node(T->t,y->leaf);
    int j=0;
    for (j=0;j<T->t;j++)
    {
        z->keys[j]=y->keys[j+T->t];
    }
    if (y->leaf==0)
    {
        for (j=0;j<T->t;j++)
        {
            z->children[j]=z->children[j+T->t];
        }
    }
    y->num = T->t-1;
    for (j=x->num;j>=i+1;j --)
    {
        x->children[j+1]=x->children[j];
    }
    x->children[i+1]=z;
    for (j = x->num-1;j>=i;j--)
    {
        x->keys[j+1] = x->keys[j];
    }
    x->keys[i] = y->keys[T->t-1];
    x->num +=1;
}
void btree_insert_nofull(btree *T,btree_node *x,KEY_TYPE key)
{
    int i =x->num-1;
    if(x->leaf)
    {
       while (i>=0&& x->keys[i]>key)
       {
           x->keys[i+1]=x->keys[i];
           i--;
       }
       x->keys[i+1]= key;
       x->num += 1;
    }
    else
    {
        while (i>=0 && x->keys[i]>key)
        {
            i--;
        }
        if (x->children[i+1]->num ==2*T->t -1)
        {
            btree_split_child(T,x,i+1);
            if (key>x->keys[i+1])
            {
                i++;
            }
        }
        btree_insert_nofull(T,x->children[i+1],key);
    
    }
}
void btree_insert(btree *T,KEY_TYPE key)
{
    struct btree_node *root=T->root;
    if (root->num==2*T->t-1)
    {
        btree_node *node =Btree_create_node(T->t,0);
        T->root =node;
        node->children[0]=root;
        btree_split_child(T,node,0);
        
    }
    

}
void btree_create(btree *T,int t)
{
    T->t = t;
    struct btree_node *x=Btree_create_node(t,1);
    T->root=x;
    
}