Table of contents
Binary search tree node deletion
src/runoob/binary/BSTRemove.java file code:
Binary search tree node deletion
Before this section introduces the deletion of binary search tree nodes, we first introduce how to find the minimum and maximum values, and delete the minimum and maximum values.
Take the minimum value as an example (the maximum value is the same):
To find the code logic for the minimum key value, search recursively to the left child node:
...
// Return the node where the minimum key value of the binary search tree with node as the root is located
private Node minimum(Node node){ if( node.left == null ) return node; return minimum(node.left); } ...
Delete the minimum key value of the binary search tree. If the node does not have a right subtree, delete it directly. If there is a right subtree, as shown in the figure:
Delete node 22, there is a right child, and only need to replace node 22 with node 33 of the right subtree.
This deletion of the minimum value is expressed in code:
...
// Delete the smallest node in the binary search tree rooted at node
// Return the root of the new binary search tree after deleting the node
private Node removeMin(Node node){ if( node.left == null ){ Node rightNode = node.right; node.right = null; count --; return rightNode; } node.left = removeMin(node.left); return node; } ...
Now we will discuss the following three cases of node deletion in a binary search tree:
1. Delete the node with only the left child, such as node 58 in the figure below.
Delete element 58 and let the left subtree directly replace the position of 58. The properties of the entire binary search tree remain unchanged.
2. Delete the node with only the right child, such as node 58 in the figure below.
Delete element 58 and let the right subtree directly replace the position of 58. The properties of the entire binary search tree remain unchanged.
3. Delete nodes that have children on the left and right, such as node 58 in the figure below.
(1) Find the minimum value in the right subtree, which is node 59
(2) Node 59 replaces node 58 to be deleted
Based on the above rules, delete the node whose key value is key in the binary search tree with node as the root. Core code example:
Source package download: Download 
https://www.runoob.com/wp-content/uploads/2020/09/runoob-algorithm-BSTRemove.zip
src/runoob/binary/BSTRemove.java file code:
package runoob.binary;
import java.util.LinkedList;
/**
* Binary search tree node deletion
*/
public class BSTRemove<Key extends Comparable<Key>, Value> { // The nodes in the tree are private classes and are not accessible to the outside world Need to know the specific implementation of binary search tree nodes private class Node { private Key key; private Value value; private Node left, right; public Node(Key key, Value value) { this.key = key; this.value = value; left = right = null; } public Node(Node node){ this.key = node.key; this.value = node.value; this.left = node.left;
this.right = node.right;
}
}
private Node root; // Root
node private int count; // Number of nodes in the tree
// Constructor, constructs an empty binary search tree by default
public BSTRemove() { root = null ; count = 0; } // Returns the number of nodes in the binary search tree public int size() { return count; } // Returns whether the binary search tree is empty public boolean isEmpty() { return count == 0; } // Insert a new (key, value) data pair into the binary search tree public void insert(Key key, Value value){ root = insert(root, key, value); } // Check whether the key key exists in the binary search tree
public boolean contain(Key key){ return contain(root, key); } // Search the value corresponding to the key key in the binary search tree. If this value does not exist, return null public Value search(Key key){ return search(root, key); } // Preorder traversal of binary search tree public void preOrder(){ preOrder(root); } // Binary search In-order traversal of the search tree public void inOrder(){ inOrder(root); } // Post-order traversal of the binary search tree public void postOrder(){ postOrder(root); } // Level-order traversal of the binary search tree public void levelOrder(){ // We use LinkedList as our queue
LinkedList<Node> q = new LinkedList<Node>();
q.add(root);
while( !q.isEmpty() ){ Node node = q.remove(); System.out.println(node.key) ; if( node.left != null ) q.add( node.left ); if( node.right != null ) q.add( node.right ); } } // Find the smallest key value of the binary search tree public Key minimum(){ assert count != 0; Node minNode = minimum( root ); return minNode.key; } // Find the maximum key value of the binary search tree public Key maximum(){ assert count != 0;
Node maxNode = maximum(root);
return maxNode.key;
}
// Remove the node with the minimum value from the binary search tree
public void removeMin(){ if( root != null ) root = removeMin( root ); } // From Delete the node with the maximum value from the binary search tree public void removeMax(){ if( root != null ) root = removeMax( root ); } // Delete the node with the key value key from the binary search tree public void remove(Key key ){ root = remove(root, key); } //******************** //* Auxiliary function for binary search tree //***** *************** // Insert node (key, value) into the binary search tree with node as the root, and use the recursive algorithm // Return the binary search tree after inserting the new node the root of
private Node insert(Node node, Key key, Value value){ if( node == null ){ count ++; return new Node(key, value); } if( key.compareTo(node.key) == 0 ) node.value = value; else if( key.compareTo(node.key) < 0 ) node.left = insert( node.left , key, value); else // key > node->key node.right = insert( node.right, key, value); return node; } // Check whether the binary search tree with node as the root contains a node with the key value, using the recursive algorithm private boolean contain(Node node, Key key){ if( node == null ) return false;
if( key.compareTo(node.key) == 0 )
return true;
else if( key.compareTo(node.key) < 0 )
return contain( node.left , key );
else // key > node->key
return contain( node.right , key );
}
// Find the value corresponding to key in the binary search tree with node as the root, recursive algorithm
// If value does not exist, return NULL
private Value search(Node node, Key key){ if( node == null ) return null; if( key.compareTo(node.key) == 0 ) return node.value; else if( key.compareTo(node.key) < 0 ) return search( node .left , key ); else // key > node->key
return search( node.right, key );
}
// Perform pre-order traversal of the binary search tree rooted at node, recursive algorithm
private void preOrder(Node node){ if( node != null ){ System.out. println(node.key); preOrder(node.left); preOrder(node.right); } } // Perform in-order traversal of the binary search tree rooted at node, recursive algorithm private void inOrder(Node node){ if( node != null ){ inOrder(node.left); System.out.println(node.key); inOrder(node.right); } } // Postorder the binary search tree rooted at node Traversal, recursive algorithm private void postOrder(Node node){
if( node != null ){ postOrder(node.left); postOrder(node.right); System.out.println(node.key); } } // Return the minimum key value of the binary search tree rooted at node The node where it is located private Node minimum(Node node){ if( node.left == null ) return node; return minimum(node.left); } // Return the node where the maximum key value of the binary search tree with node as the root is located. private Node maximum(Node node){ if( node.right == null ) return node; return maximum(node.right); } // Delete the smallest node in the binary search tree rooted at node // Return to delete node The root of the new binary search tree
private Node removeMin(Node node){ if( node.left == null ){ Node rightNode = node.right; node.right = null; count --; return rightNode; } node.left = removeMin(node.left); return node; } // Delete the largest node in the binary search tree with node as the root // Return the root of the new binary search tree after deleting the node private Node removeMax(Node node){ if( node.right == null ) { Node leftNode = node.left; node.left = null; count --; return leftNode; } node.right = removeMax(node.right);
return node;
}
// Delete the node whose key value is key in the binary search tree with node as the root, recursive algorithm
// Return the root of the new binary search tree after deleting the node
Node remove(Node node, Key key){ if ( node == null ) return null; if( key.compareTo(node.key) < 0 ){ node.left = remove( node.left , key ); return node; } else if( key.compareTo(node.key ) > 0 ){ node.right = remove( node.right, key ); return node; } else{ // key == node->key // The left subtree of the node to be deleted is empty if( node.left == null ){ Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
// When the right subtree of the node to be deleted is empty
if( node.right == null ){ Node leftNode = node.left; node.left = null; count --; return leftNode; } // When the left and right subtrees of the node to be deleted are not empty // Find the smallest node larger than the node to be deleted, that is, the smallest node of the right subtree of the node to be deleted // Use this node to replace the node to be deleted Remove the position of the node Node successor = new Node(minimum(node.right)); count ++; successor.right = removeMin(node.right); successor.left = node.left;
node.left = node.right = null;
count --;
return successor;
}
}
}