//往一颗B树插入一个关键字elem
btree_node* btree_insert(btree_node *btree, int elem) {
//如果root结点是一个满结点
if (btree->num == 2 * T - 1) {
//创建一个新结点，作为新root结点
btree_node *new_root = NULL;
new_root = malloc(sizeof(btree_node));
if (new_root == NULL) {
fprintf(stderr, "Error:Can't allocate neccessary space!");
exit(1);
}
new_root->is_leaf = 0;
new_root->num = 0;
new_root->ptr[0] = btree;
//对旧root结点进行分裂
btree_split_child(new_root, 0, btree);
btree_insert_nonfull(new_root, elem);
return new_root;
}
else
{
btree_insert_nonfull(btree, elem);
return btree;
}
}
btree_node* btree_insert(btree_node *root, int target)
{
if(NULL == root)
{
return NULL;
}
if(2 * M - 1 == root->num)
{
btree_node *node = btree_node_new();
if(NULL == node)
{
return root;
}
node->is_leaf = 0;
node->p[0] = root;
btree_split_child(node, 0, root);
btree_insert_nonfull(node, target);
return node;
}
else
{
btree_insert_nonfull(root, target);
return root;
}
}
void BPlusTree::btree_insert_nonfull(btree_node *node, int target)
{
if(true == node->is_leaf) {
int pos = node->num;
while(pos >= 1 && target < node->k[pos-1]) {
node->k[pos] = node->k[pos-1];
pos--;
}
node->k[pos] = target;
node->num += 1;
btree_node_num+=1;
} else {
int pos = node->num;
while(pos > 0 && target < node->k[pos-1]) {
pos--;
}
if(2 * M -1 == node->p[pos]->num) {
btree_split_child(node, pos, node->p[pos]);
if(target > node->k[pos]) {
pos++;
}
}
btree_insert_nonfull(node->p[pos], target);
}
}
static void
btree_insert_nonfull(struct btree_s *tree, struct bnode_s *node, int k)
{
if (node->leaf) {
int i = node->nkeys-1;
while (i >= 0 && k < node->key[i]) {
node->key[i+1] = node->key[i];
i--;
}
node->key[i+1] = k;
node->nkeys++;
} else {
int i = node->nkeys-1;
while (i >= 0 && k < node->key[i]) {
i--;
}
int child_pos = RIGHT_CHILD_OF_KEY(i); /* 插入到这个key有边的child的位置 */
if (node->child[child_pos]->nkeys == tree->max_key_nr) {
split_node(tree, node, child_pos);
if (k > node->key[RIGHT_KEY_OF_CHILD(child_pos)]) { /* 新插入的key在这个child的右边 */
/* 插入到新的孩子节点 */
child_pos++;
}
}
btree_insert_nonfull(tree, node->child[child_pos], k);
}
}
void btree_insert( BTreeNode *& root, Key k )
{
BTreeNode * r = root;
BTreeNode * s;
int d = root->min_degree;
if( r->n == 2*d - 1 ) {
s = new BTreeNode( d );
root = s;
s->leaf = false;
s->n = 0;
s->children[0] = r;
btree_split_child( s, 0 );
btree_insert_nonfull( s, k );
}
else {
btree_insert_nonfull( r, k );
}
}
/**
* Function used to insert node into a B-Tree
* @param root Root of the B-Tree
* @param node The node to be inserted
* @param compare Function used to compare the two nodes of the tree
* @return success or failure
*/
int btree_insert_key(btree * btree, bt_key_val * key_val)
{
bt_node * rnode;
rnode = btree->root;
if(rnode->nr_active == (2*btree->order - 1))
{
bt_node * new_root;
new_root = allocate_btree_node(btree->order);
new_root->level = btree->root->level + 1;
btree->root = new_root;
new_root->leaf = false;
new_root->nr_active = 0;
new_root->children[0] = rnode;
btree_split_child(btree,new_root,0,rnode);
btree_insert_nonfull(btree,new_root,key_val);
}
else
btree_insert_nonfull(btree,rnode,key_val);
return 0;
}
void
btree_insert(struct btree_s *tree, int k)
{
struct bnode_s *r = tree->root;
if (r->nkeys == tree->max_key_nr) {
struct bnode_s *new_root = alloc_node(tree->max_key_nr, tree->max_child_nr);
new_root->nkeys = 0;
new_root->child[0] = r;
new_root->leaf = 0;
tree->root = new_root;
split_node(tree, new_root, 0);
}
btree_insert_nonfull(tree, tree->root, k);
}
//往一个非满结点 nonfull_node中插入一个关键字elem
void btree_insert_nonfull(btree_node *nonfull_node, int elem)
{
//获取该结点的key值个数
int key_idx = nonfull_node->num - 1;
//如果待插入的非满结点为叶子结点，将关键字直接插入
if (nonfull_node->is_leaf == 1)
{
//根据结点关键字大小的顺序，定位要插入关键字的位置
while(key_idx>=0 && nonfull_node->key[key_idx]>elem)
{
nonfull_node->key[key_idx+1] = nonfull_node->key[key_idx];
key_idx--;
}
nonfull_node->key[key_idx+1] = elem;
nonfull_node->num += 1;
}
else //如果待插入非满结点为内结点，则一直查找到一个叶子结点为止
{
while(key_idx>=0 && nonfull_node->key[key_idx]>elem)
key_idx--;
key_idx = key_idx+1;
//沿着B树结点下移到子结点
btree_node *child_node = nonfull_node->ptr[key_idx];
//如果子结点是满的，则先进行分裂
if (child_node->num == 2*T-1)
{
//按照结点的中间位置（T-1）进行分裂
btree_split_child(nonfull_node, key_idx, child_node);
//分裂后nonfull_node产生两个新的子节点，需确定往哪个子节点递归
if (nonfull_node->key[key_idx] < elem)
key_idx = key_idx + 1;
}
btree_insert_nonfull(nonfull_node->ptr[key_idx], elem);
}
}
void btree_insert_nonfull( BTreeNode * node, Key k )
{
int i = node->n - 1;
if( node->leaf ) {
for( int j = 0; j < node->n; ++j )
if( node->keys[j] == k )
return;
for( ; i >= 0 && k < node->keys[i]; --i ) {
node->keys[i+1] = node->keys[i];
}
node->keys[i+1] = k;
++node->n;
}
else {
for( ; i >= 0 && k < node->keys[i]; --i );
++i;
if( node->children[i]->n == 2*node->min_degree - 1 ) {
btree_split_child( node, i );
if( k > node->keys[i] )
++i;
}
btree_insert_nonfull( node->children[i], k );
}
}
