B 树 B+树_struct btree *node-CSDN博客

本文链接：https://blog.csdn.net/qq_21919455/article/details/121339151

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);

   }