void AreaTree::recDelete( areaTreeNode * at )
{ if( at == NULL )
return;
recDelete( at->left );
recDelete( at->right );
at = NULL;
}
void Btree<T>::recDelete(T& x,
unsigned ptr,
Boolean& found)
//
//
// Purpose: function that performs node deletion.
//
// Parameters:
//
// input: x - the data to be removed
// ptr - the
//
// output:
// found - flag that indicates whether item x was found
//
{
Bstruct<T> *buf, *buf2;
unsigned i;
if (ptr == BTREE_NIL)
found = FALSE;
else {
buf = new Bstruct<T>;
readNode(buf, ptr);
// search for x in the current node
found = (searchNode(x, buf, i)) ? TRUE : FALSE;
// found an element that matches item x?
if (found) {
// does ptr point to a leaf node?
if (buf->nodeLink[i - 1] == BTREE_NIL) {
// remove element at index i
trim(buf, i);
writeNode(buf, ptr);
}
else {
// replace data[i] with its successor in node ptr
successor(buf, i);
writeNode(buf, ptr);
recDelete(buf->data[i], buf->nodeLink[i], found);
}
}
else
recDelete(x, buf->nodeLink[i], found);
if (buf->nodeLink[i] != BTREE_NIL) {
buf2 = new Bstruct<T>;
readNode(buf2, buf->nodeLink[i]);
if (buf2->count < BTREE_MIN) {
restore(buf, i);
writeNode(buf, ptr);
}
delete buf2;
}
delete buf;
}
}
int recDelete(rect *r, node *n, int pos){
int i,j;
node *n1, *n2;
if(n->leaf){
for(i = 0; i < n->size; ++i)
if(n->values[i]->child == pos){
deleteValue(n, i);
writeNode(n);
return TRUE;
}
return FALSE;
}
for(i = 0; i < n->size; ++i)
if(intersect(r, n->values[i]->r)){
n1 = readNode(n->values[i]->child);
if(recDelete(r, n1, pos)){
n->values[i]->r = dupRect(n1->MBR);
if(n1->size < b )
underflow(n, n1, i);
else{
refreshMBR(n);
writeNode(n);
freeNode(n1);
}
return TRUE;
}
else
freeNode(n1);
}
return FALSE;
}
Boolean Btree<T>::remove(T& x)
//
//
// Purpose: performs node deletion. The function returns TRUE if
// item x was deleted from the B-tree.
//
// Parameters:
//
// input: x - the data to be removed
//
{
Bstruct<T> *buf = new Bstruct<T>;
unsigned p;
Boolean found;
recDelete(x, root, found);
if (found) {
numData--; // decrement data counter
readNode(buf, root);
// is the node empty?
if (buf->count == 0) {
p = root;
root = buf->nodeLink[0];
// delete node at index p
numDelNodes++; // increment the counter for the number
// of deleted nodes
// does the array delNodeArray need to expand?
if (numDelNodes == countDelNodeArray)
expandDelNodeArray();
// assign index q to an element of array delNodeArray
*(delNodeArray + numDelNodes - 1) = p;
// decrement the node counter
numNodes--;
}
}
delete buf;
return found;
}
AreaTree::~AreaTree()
{ recDelete( root );
}
