//暂时用来测试删除合并 test success
void TreeBase::remove(size_t position)
{
size_t offset;
position += 1;
node_leaf* leaf = find(position, root_, offset);
delete_leaf(leaf);
}
void select_delete(unsigned int* number_of_nodes)
{
if(0 == *number_of_nodes){
puts("the tree is basically empty, first create a root node and some leafs to delete");
return;
}
unsigned int select=0;
do{
printf("\n\navailable delete operations:\n");
printf("0\tcancel\n");
printf("1\tdelete a leaf\n");
printf("2\tdelete a tree part\n");
printf("3\tdelete a node\n");
readdigit(&select, "select an operation:");
if(1 == select){
if(0 == *number_of_nodes){
puts("the tree is empty, first create one before you like to delete the entire thing!");
}else{
if(0 > delete_tree(number_of_nodes)){
puts("failed.");
}else{
printf("%d elements\ndone.\n", *number_of_nodes);
}
}
break;
}else if(2 == select){
if(0 > delete_leaf(number_of_nodes)){
puts("failed.");
}else{
printf("deleted.\n%d elements\ndone.\n", *number_of_nodes);
}
break;
}else if(3 == select){
if(0 > delete_element(number_of_nodes)){
puts("failed.");
}else{
printf("deleted.\n%d elements\ndone.\n", *number_of_nodes);
}
break;
}
}while(0 != select);
}
int tau_delete (tree_s *tree, u64 key)
{
void *child;
branch_s *parent;
snint k;
int rc;
FN;
child = tau_bget(tree_inode(tree), root(tree));
for (;;) {
if (!child) return qERR_NOT_FOUND;
if (magic(child) == LEAF) {
break;
}
parent = child;
k = binary_search_branch(key, parent->br_key, parent->br_num);
join_node(tree, parent, k);
child = tau_bget(tree_inode(tree), parent->br_key[k].k_block);
tau_bput(parent);
}
rc = delete_leaf(tree, child, key);
tau_bput(child);
return rc;
}
void TreeBase::modify(size_t position_begin, size_t position_end, size_t src_index)
{
if (position_begin >= position_end) return;
size_t offset_l = 0, offset_r = 0;
position_begin += 1;
position_end += 1;
node_leaf* _dst_l = find(position_begin, root_, offset_l);
node_leaf* _dst_r = find(position_end, root_, offset_r);
if (_dst_l == NULL || _dst_r == NULL) return;
//在一个节点的中间改变字体
//1. tune_down 两次insert
if (_dst_l == _dst_r)
{
if (_dst_l->src_index == src_index) return;
else if (offset_l == 1)
{
if (_dst_l->left != NULL && _dst_l->left->src_index == src_index)
{
_dst_l->count -= offset_r - offset_l;
_dst_l->left->count += offset_r - offset_l;
if (_dst_l->parent != _dst_l->left->parent)
{
tune_down(_dst_l->parent, offset_r - offset_l);
tune_up(_dst_l->left->parent, offset_r - offset_l);
}
if (_dst_l->count == 0)
delete_leaf(_dst_l);
}
else
{
if (_dst_l->count == offset_r - offset_l)
_dst_l->src_index = src_index;
else
{
_dst_l->count -= offset_r - offset_l;
node_leaf* new_leaf = new node_leaf();
new_leaf->src_index = src_index;
new_leaf->count = offset_r - offset_l;
new_leaf->parent = _dst_l->parent;
new_leaf->right = _dst_l;
new_leaf->left = _dst_l->left;
if (_dst_l->left != NULL)
{
_dst_l->left->right = new_leaf;
add_child_before(_dst_l->parent, _dst_l, new_leaf);
}
else
{
src_head_ = new_leaf;
_dst_l->parent->childs.push_front(new_leaf);
}
_dst_l->left = new_leaf;
if (new_leaf->parent->childs.size() > MAX_CHILD_INDEX)
split(new_leaf->parent);
}
}
}
else
{
if (_dst_l->count + 1 - offset_r != 0)
{
node_leaf* new_leaf_r = new node_leaf();
new_leaf_r->src_index = _dst_l->src_index;
new_leaf_r->count = _dst_l->count + 1 - offset_r;
_dst_l->count = offset_r - 1;
new_leaf_r->parent = _dst_l->parent;
new_leaf_r->left = _dst_l;
if (_dst_l->right != NULL)
{
_dst_l->right->left = new_leaf_r;
new_leaf_r->right = _dst_l->right;
_dst_l->right = new_leaf_r;
add_child_after(_dst_l->parent, _dst_l, new_leaf_r);
}
else
{
_dst_l->right = new_leaf_r;
src_tail_ = new_leaf_r;
_dst_l->parent->childs.push_back(new_leaf_r);
}
if (_dst_l->parent->childs.size() > MAX_CHILD_INDEX)
split(_dst_l->parent);
}
node_leaf* new_leaf_m = new node_leaf();
new_leaf_m->src_index = src_index;
new_leaf_m->parent = _dst_l->parent;
new_leaf_m->count = _dst_l->count + 1 - offset_l;
_dst_l->count = offset_l - 1;
new_leaf_m->left = _dst_l;
new_leaf_m->right = _dst_l->right;
if (_dst_l->right) _dst_l->right->left = new_leaf_m;
_dst_l->right = new_leaf_m;
add_child_after(_dst_l->parent, _dst_l, new_leaf_m);
if (_dst_l->parent->childs.size() > MAX_CHILD_INDEX)
split(_dst_l->parent);
}
}
else
{
//左右指向不同的节点，先处理最左边的节点
node_leaf* join = _dst_l;
node_leaf* next = _dst_l->right;
size_t added = 0;
if (offset_l == 1)
{
if (_dst_l->left != NULL && _dst_l->left->src_index == src_index)
{
join = _dst_l->left;
added += _dst_l->count;
delete_leaf(_dst_l);
}
else
_dst_l->src_index = src_index;
}
else
{
if (_dst_l->src_index != src_index)
{
node_leaf* new_leaf = new node_leaf();
new_leaf->src_index = src_index;
new_leaf->count = _dst_l->count + 1 - offset_l;
_dst_l->count = offset_l - 1;
new_leaf->parent = _dst_l->parent;
new_leaf->left = _dst_l;
new_leaf->right = _dst_l->right;
_dst_l->right->left = new_leaf;
_dst_l->right = new_leaf;
add_child_after(_dst_l->parent, _dst_l, new_leaf);
if (_dst_l->parent->childs.size() > MAX_CHILD_INDEX)
split(_dst_l->parent);
join = new_leaf;
}
}
node_leaf* temp;
while (next != _dst_r)
{
temp = next;
next = next->right;
added += temp->count;
delete_leaf(temp);
}
if (offset_r != 1)
{
if (offset_r == _dst_r->count + 1 || _dst_r->src_index == src_index)
{
added += _dst_r->count;
delete_leaf(_dst_r);
}
else
{
_dst_r->count -= offset_r - 1;
added += offset_r - 1;
tune_down(_dst_r->parent, offset_r - 1);
}
}
else
{
if (_dst_r->src_index == src_index)
{
added += _dst_r->count;
delete_leaf(_dst_r);
}
}
join->count += added;
tune_up(join->parent, added);
//将中间节点数量加到最左边处理节点，然后依次删除中间节点
//然后处理最右边的节点
}
//一个节点中间和另一个节点中间
//判断是否分离出新节点
}
void TreeBase::remove(size_t position_begin, size_t position_end)
{
if (position_begin >= position_end) return;
size_t offset_l = 0, offset_r = 0;
position_begin += 1;
position_end += 1;
node_leaf* _dst_l = find(position_begin, root_, offset_l);
node_leaf* _dst_r = find(position_end, root_, offset_r);
if (_dst_l == NULL || _dst_r == NULL) return;
node_leaf* left_compare = NULL;
if (_dst_l == _dst_r)
{
if (offset_r - offset_l == _dst_l->count)
{
left_compare = _dst_l->left;
delete_leaf(_dst_l);
}
else
{
_dst_l->count -= offset_r - offset_l;
tune_down(_dst_l->parent, offset_r - offset_l);
left_compare = _dst_l;
}
}
else
{
node_leaf* next = _dst_l->right;
if (offset_l == 1)
{
left_compare = _dst_l->left;
delete_leaf(_dst_l);
}
else
{
tune_down(_dst_l->parent, _dst_l->count + 1 - offset_l);
_dst_l->count = offset_l - 1;
left_compare = _dst_l;
}
while (next != _dst_r)
{
node_leaf* tmp = next;
next = next->right;
delete_leaf(tmp);
}
if (offset_r == _dst_r->count + 1)
delete_leaf(_dst_r);
else
{
tune_down(_dst_r->parent, offset_r - 1);
_dst_r->count -= offset_r - 1;
}
}
if (left_compare != NULL && left_compare->right != NULL
&& left_compare->src_index == left_compare->right->src_index)
{
left_compare->count += left_compare->right->count;
tune_up(left_compare->parent, left_compare->right->count);
delete_leaf(left_compare->right);
}
}
void Bst<generic>::remove (generic x)
{
Btn<generic> * temp ;
//throw exception if empty
if (empty())
{
throw Exception
(
CONTAINER_EMPTY,
"The container is empty. You canot make it smaller."
);
}
//find node with data were looking for
temp = p_search (x);
//if the item to be deleted exists
if (temp != NULL)
{
//node to delete has no children
if (temp->left == NULL && temp->right == NULL )
{
delete_leaf (temp);
}
//node to delete has two children
else if (temp->left != NULL && temp->right != NULL )
{
//move temp2 down to left right most
Btn<generic> * temp2 ;
temp2 = temp;
if (temp2->left !=NULL)
temp2 = temp2->left;
while ( temp2->right != NULL )
{
temp2 = temp2->right ;
}
//swap data in node to delete
swap(temp , temp2);
//node to delete has no children
if (temp2->left == NULL && temp2->right == NULL )
{
delete_leaf ( temp2 ) ;
}
//node to delete has one child
else
{
//cerr << temp2 << endl;
delete_link ( temp2 ) ;
}
}
//node to delete has one child
else
{
delete_link ( temp ) ;
}
}
}
