//
// Remove largest item in BST subtree rooted at ptr
// Returns pointer to modified subtree.
// Pointer to max node found is stored in reference parameter max_pptr
//
tnode *bst_remove_max(tnode *ptr, tnode **max_pptr) {
tnode *left ;
// NULL pointer is an error condition
if (ptr == NULL) {
fprintf(stderr, "Can't remove max node from NULL pointer!\n") ;
exit(1) ;
}
// If right subtree exists, max is in right subtree
if (ptr->right != NULL) {
ptr->right = bst_remove_max(ptr->right, max_pptr) ;
ptr->size-- ;
return ptr ; // root of modified subtree is current node
} else { // no right subtree
// if no right subtree, then current node is max
left = ptr->left ; // save
ptr->left = NULL ; // clean up current node
ptr->right = NULL ;
ptr->size = 1 ;
*max_pptr = ptr ; // max is current node
return left ; // modified subtree is left subtree
}
}
// write definition for bst_remove_max here
void bst_remove_max(btNode* &root, int &rootData)
{
if (root->right == 0)
{
rootData = root->data;
btNode* oldRoot = root;
root = root->left;
delete oldRoot;
}
else
bst_remove_max(root->right, rootData);
}
void bst_remove_max(binary_tree_node*& root_ptr, int& removed)
// Precondition: root_ptr is a root pointer of a non-empty binary
// search tree.
// Postcondition: The largest item in the binary search tree has been
// removed, and root_ptr now points to the root of the new (smaller)
// binary search tree. The reference parameter, removed, has been set
// to a copy of the removed item.
{
if (root_ptr->right != nullptr)
bst_remove_max(root_ptr->right, removed);
else
{
removed = root_ptr->data;
binary_tree_node* old_root_ptr = root_ptr;
root_ptr = root_ptr->left;
delete old_root_ptr;
old_root_ptr = nullptr;
}
}
// write definition for bst_remove here
bool bst_remove(btNode* &root, int remInt)
{
if (root == 0) // tree empty or doesn't contain the remInt
return false;
if (remInt < root->data) // left child
bst_remove(root->left, remInt);
else if (remInt > root->data) // right child
bst_remove(root->right, remInt);
else if (remInt == root->data)
{
if(root->left == 0 && root->right == 0) // no children
{
btNode* oldRoot = root;
root = 0;
delete oldRoot;
}
else if (root->left == 0 || root->right == 0)
{
if (root->right == 0) // left child only
{
btNode* oldRoot = root;
root = root->left;
delete oldRoot;
}
else // right child only
{
btNode* oldRoot = root;
root = root->right;
delete oldRoot;
}
}
else // two children
bst_remove_max(root->left, root->data);
return true; // node successfully removed
}
}
bool bst_remove(binary_tree_node*& root_ptr, const int& target)
// Precondition: root_ptr is a root pointer of a binary search tree
// or may be nullptr for an empty tree).
// Postcondition: If target was in the tree, then one copy of target
// has been removed, and root_ptr now points to the root of the new
// (smaller) binary search tree. In this case the function returns true.
// If target was not in the tree, then the tree is unchanged (and the
// function returns false).
{
if (root_ptr == nullptr) return false;
if (target < root_ptr->data)
return bst_remove(root_ptr->left, target);
if (target > root_ptr->data)
return bst_remove(root_ptr->right, target);
if (root_ptr->left == nullptr)
{
binary_tree_node* old_root = root_ptr;
root_ptr = root_ptr->right;
delete old_root_ptr;
return true;
}
bst_remove_max(root_ptr->left, root_ptr->data);
return true;
}
tnode *bst_remove(tnode *ptr, int key, int *pfound) {
tnode *max_node_ptr, *temp_ptr ;
if (ptr == NULL) { // not in NULL tree
*pfound = 0 ;
return NULL ;
}
if (ptr->data < key) { // too big, remove from right
ptr->right = bst_remove(ptr->right, key, pfound) ;
if (*pfound) ptr->size-- ;
return ptr ;
} else if (key < ptr->data) { // too small, remove from left
ptr->left = bst_remove(ptr->left, key, pfound) ;
if (*pfound) ptr->size-- ;
return ptr ;
} else { // ptr->data == key
// just right, remove current node
*pfound = 1 ;
// removing current node is broken down into cases
// depending on whether current node has any subtrees.
// Case 1: no right subtree
// left subtree becomes root of modified subtree
//
if (ptr->right == NULL) {
temp_ptr = ptr->left ;
ptr->left = NULL ; // paranoid
ptr->right = NULL ;
free(ptr) ;
return temp_ptr ;
// Case 2: no left subtree
// right subtree becomes root of modified subtree
//
} else if (ptr->left == NULL) {
temp_ptr = ptr->right ;
ptr->left = NULL ; // paranoid
ptr->right = NULL ;
free(ptr) ;
return temp_ptr ;
// Case 3: has both subtrees
// Remove max item from left subtree and make
// that the new root of current subtree
//
} else { // neither child is NULL
// remove max item from left subtree
ptr->left = bst_remove_max(ptr->left, &max_node_ptr) ;
// max item takes over as root.
max_node_ptr->left = ptr->left ;
max_node_ptr->right = ptr->right ;
max_node_ptr->size = ptr->size - 1 ;
// Remove current item
ptr->left = NULL ; // paranoid
ptr->right = NULL ;
free(ptr) ;
return max_node_ptr ;
}
}
}
