View more

View more

View more

### Image of the Day Submit

IOTD | Top Screenshots

### The latest, straight to your Inbox.

Subscribe to GameDev.net Direct to receive the latest updates and exclusive content.

# Binary Search Tree Remove Node Critique

Old topic!

Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

2 replies to this topic

### #1SolarChronus  Members

Posted 03 November 2012 - 07:23 PM

I have written the code needed to remove a node from a non-self balancing BST. I've put it through every test I could think of and it seems to be pretty solid, but the method is pretty long. I have been trying to figure out a way to re-factor it to make it more streamlined (if that is possible?). However I haven't had much luck. The code for removing a node with a single child is pretty much identical. The only difference is that the children they get/set are their opposite. I figure some special pointer magic would make this work but haven't had any luck.

template<class T>
void BinarySearchTree<T>::remove(BSTNode<T>* nodeToDelete)
{
sorted = false;
if(nodeToDelete->getLeftChild() == nullptr && nodeToDelete->getRightChild() == nullptr) //No Children
{
if(root == nodeToDelete)
root = nullptr;
setParentsChildNodeToNull(nodeToDelete);
eraseNode(nodeToDelete);
}
else if(nodeToDelete->getRightChild() == nullptr)		  //Left child only
{
BSTNode<T>* newRoot = maximum(nodeToDelete->getLeftChild());

if(nodeToDelete->getLeftChild() != newRoot)
{
if(newRoot->getLeftChild())
{
newRoot->getParent()->setRightChild(newRoot->getLeftChild());
newRoot->getLeftChild()->setParent(newRoot->getParent());
}
else
{
newRoot->getParent()->setRightChild(nullptr);
}
nodeToDelete->getLeftChild()->setParent(newRoot);
newRoot->setLeftChild(nodeToDelete->getLeftChild());
}
newRoot->setParent(nodeToDelete->getParent());
if(newRoot->getParent() != nullptr)
replaceOldChildInParent(nodeToDelete, newRoot);
if(nodeToDelete == root)
root = newRoot;
eraseNode(nodeToDelete);
}
else if(nodeToDelete->getLeftChild() == nullptr)		  //Right child only
{
BSTNode<T>* newRoot = minimum(nodeToDelete->getRightChild());

if(nodeToDelete->getRightChild() != newRoot)
{
if(newRoot->getRightChild())
{
newRoot->getParent()->setLeftChild(newRoot->getRightChild());
newRoot->getRightChild()->setParent(newRoot->getParent());
}
else
{
newRoot->getParent()->setLeftChild(nullptr);
}
nodeToDelete->getRightChild()->setParent(newRoot);
newRoot->setRightChild(nodeToDelete->getRightChild());
}
newRoot->setParent(nodeToDelete->getParent());
if(newRoot->getParent() != nullptr)
replaceOldChildInParent(nodeToDelete, newRoot);
if(nodeToDelete == root)
root = newRoot;
eraseNode(nodeToDelete);
}
else					 //Both children exsist
{
BSTNode<T>* newRoot = maximum(nodeToDelete->getLeftChild());
if(nodeToDelete->getLeftChild() != newRoot)
{
if(newRoot->getLeftChild())
{
newRoot->getParent()->setRightChild(newRoot->getLeftChild());
newRoot->getLeftChild()->setParent(newRoot->getParent());
}
else
{
newRoot->getParent()->setRightChild(nullptr);
}
nodeToDelete->getLeftChild()->setParent(newRoot);
newRoot->setLeftChild(nodeToDelete->getLeftChild());
}
newRoot->setRightChild(nodeToDelete->getRightChild());
newRoot->getRightChild()->setParent(newRoot);
newRoot->setParent(nodeToDelete->getParent());
if(newRoot->getParent() != nullptr)
replaceOldChildInParent(nodeToDelete, newRoot);
if(nodeToDelete == root)
root = newRoot;
eraseNode(nodeToDelete);
}
}


### #2Kyall  Members

Posted 04 November 2012 - 02:08 AM

Seems like a lot of code to remove a node. Wait, just looked over my own binary tree delete code.

tree* left = node->left, right = node->right;
// Has 2 Children
if( left->value && right->value ) {
// Move left nodes to leftmost right node
// Get leftmost right node
tree* successor = right;
while( successor->left->value )
successor = successor->left;
delete successor->left;
successor->left = left;
// Replace this node with right node
delete node->value;
node->value = right->value;
node->left = right->left;
node->right = right->right;
delete right;
}
// Has left child
else if( left->value ) {
// No right value, so delete
delete right;
// Delete this node's value and replace it with left node value
delete node->value;
node->value = left->value;
node->left = left->left;
node->right = left->right;
// Delete left node
delete left;
} else if( right->value ) {
// No left value so delete
delete left;
// Delete this node's value and replace it with right node value
delete node->value;
node->value = right->value;
node->left = right->left;
node->right = right->right;
// Delete right node
delete right;
} else {
// This node becomes dead leaf
delete node->value;
node->value = NULL;
delete left;
delete right;
}
return node;

I say Code! You say Build! Code! Build! Code! Build! Can I get a woop-woop? Woop! Woop!

### #3iMalc  Members

Posted 05 November 2012 - 02:38 AM

For reference, here's an ordered binary tree remove function that I wrote some time ago which uses the less-than operator for ordering and returns the removed node rather than deleting it:
// O(n) : Remove selected item - caller responsible for deallocation
template <class TNode, class TKey>
TNode *TreeRemove(TNode *&head, TKey &rem) {
TNode *found;
//unexpected case: the item was not even in the tree
} else if (rem < *head) {
//the item to be removed is in the left sub-tree
} else if (*head < rem) {
//the item to be removed is in the right sub-tree
} else {
//if we got here then we have found the item
//there is no left node, put the right one as the new parent
//the right could be NULL, but if so this also does what we want.
} else if (head->right == NULL) {
//there was no right node, but we already know there is a left one so use that
} else {
//difficult case: We need to find a replacement for this node in the tree.
//this uses leftmost node of the right sub-tree
//now copy all of the old details in the node being reused
//switch it with the old one
}
return found;
}
}
template <class TNode>
TNode *found;
//special case used for finding the node to replace a higher deleted node
else {
//if we got here then we have found the item
//there is no left node, put any right one as the new parent
}
return found;
}
I think you'll agree that it's considerably less complex, and probably still shorter despite the thorough commenting.

Edited by iMalc, 05 November 2012 - 02:40 AM.

"In order to understand recursion, you must first understand recursion."
My website dedicated to sorting algorithms

Old topic!

Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.