Define tree nodes
Define the attributes of tree nodes and the middle order traversal method
class Node { int value; Node left; Node right; public Node(int value) { this.value = value; } //Medium order traversal //The result of a binary tree traversed in middle order is ordered public void infixOrder() { if(this.left != null) { this.left.infixOrder(); } System.out.println(this); if(this.right != null) { this.right.infixOrder(); } } }
Define the method of constructing binary sort tree by tree node (add tree node)
public void add(Node node) { if(node == null) { return; } //Judge the value of the incoming node and the value relationship with the root node of the current subtree if(node.value < this.value) { //If the left child node of the current node is null if(this.left == null) { this.left = node; } else { //Recursively add to the left subtree this.left.add(node); } } else { //The value of the added node is greater than the value of the current node if(this.right == null) { this.right = node; } else { //Recursive right subtree addition this.right.add(node); } } }
Defines the lookup method for tree nodes
/** * * @param value The value of the node you want to delete * @return If the node is found, null is returned */ public Node search(int value) { if(value == this.value) { //This node is found return this; } else if(value < this.value) {//If the search value is less than the current node, the left subtree will be searched recursively //If the left child node is empty, the search fails if(this.left == null) { return null; } return this.left.search(value); } else { //If the search value is not less than the current node, recursively search the right subtree //If the right child node is empty, the search fails if(this.right == null) { return null; } return this.right.search(value); } }
Define the method to find the parent node of the node to be deleted (for deletion operation)
/** * * @param value The value of the node to find * @return The parent node of the node to be deleted is returned. If not, null is returned */ public Node searchParent(int value) { //If the current node is the parent node of the node to be deleted, return if((this.left != null && this.left.value == value)  (this.right != null && this.right.value == value)) { return this; } else { //If the searched value is less than the value of the current node, and the left child node of the current node is not empty if(value < this.value && this.left != null) { return this.left.searchParent(value); //Left subtree recursive lookup } else if (value >= this.value && this.right != null) { return this.right.searchParent(value); //Recursive search of right subtree } else { return null; // Parent node not found } } }
Define binary sort tree
Define the root node and the middle order traversal method
class BinarySortTree { private Node root; public Node getRoot() { return root; } //Medium order traversal public void infixOrder() { if(root != null) { root.infixOrder(); } else { System.out.println("Binary sort tree is empty and cannot be traversed"); } } }
Define the construction method of binary sort tree
public void add(Node node) { if(root == null) { root = node;//If root is empty, direct root to node } else { root.add(node); } }
Define the method of finding nodes in binary sort tree
public Node search(int value) { if(root == null) { return null; } else { return root.search(value); } }
Define a binary sort tree method to find the parent node of the node to be deleted (for deletion)
public Node searchParent(int value) { if(root == null) { return null; } else { return root.searchParent(value); } }
Defines a method to find a binary sort tree, find the smallest node and delete it (for deletion)
//1. The returned information of the smallest node of the binary sort tree with node as the root node //2. Delete the minimum node of the binary sort tree with node as the root node /** * * @param node Incoming node (as the root node of binary sort tree) * @return Returns the information of the smallest node of the binary sort tree with node as the root node */ public int delRightTreeMin(Node node) { Node target = node; //Loop to find the left child node, and the minimum value will be found //Because the leftmost node is the minimum while(target.left != null) { target = target.left; } //At this point, the target points to the smallest node //Delete minimum node delNode(target.value); return target.value; }
Define the method of deleting nodes in binary sort tree
There are three ways to delete a node
 The node to be deleted is a leaf node

You need to find the targetNode to delete first

Find the parent node of targetNode

Determines whether the targetNode is the left child node or the right child node of the parent

Delete according to the previous situation
Left child node parent left = null
Right child node parent right = null;
 Delete nodes with only one subtree

You need to find the targetNode to delete first

Find the parent node of targetNode

Determines whether the targetNode has a left child node or a right child node

Determines whether the targetNode is the left child node or the right child node of the parent
 If the targetNode has a left child node
① if the targetNode is the left child node of the parent
parent.left = targetNode.left;
② if the targetNode is the right child node of the parent
parent.right = targetNode.left;
 If the targetNode has a right child node
① if the targetNode is the left child node of the parent
parent.left = targetNode.right;
② if the targetNode is the right child node of the parent
parent.right = targetNode.right

Delete a node with two subtrees

You need to find the targetNode to delete first

Find the parent node of targetNode

Find the smallest node from the left subtree of targetNode

Use a temporary variable temp to save the information of the smallest node

Delete the minimum node

Assign the information of the smallest node to the node to be deleted
targetNode.value = temp
The results show that the node to be deleted is not deleted, but the smallest node is deleted

public void delNode(int value) { if(root == null) { return; }else { //1. First find the targetNode to be deleted Node targetNode = search(value); //If the node to be deleted is not found if(targetNode == null) { return; } //If we find that the current binary sort tree has only one node if(root.left == null && root.right == null) { root = null; return; } //To find the parent node of targetNode Node parent = searchParent(value); //If the node to be deleted is a leaf node if(targetNode.left == null && targetNode.right == null) { //Judge whether the targetNode is the left child node or the right child node of the parent node if(parent.left != null && parent.left.value == value) { //Is the left child node parent.left = null; } else if (parent.right != null && parent.right.value == value) {//Is a child node parent.right = null; } } else if (targetNode.left != null && targetNode.right != null) { //Delete a node with two subtrees int minVal = delRightTreeMin(targetNode.right); targetNode.value = minVal; } else { // Delete nodes with only one subtree //If the node to be deleted has a left child node if(targetNode.left != null) { if(parent != null) { //If the targetNode is the left child node of the parent if(parent.left.value == value) { parent.left = targetNode.left; } else { // targetNode is the right child node of the parent parent.right = targetNode.left; } } else { root = targetNode.left; } } else { //If the node to be deleted has a right child node if(parent != null) { //If the targetNode is the left child node of the parent if(parent.left.value == value) { parent.left = targetNode.right; } else { //If the targetNode is the right child node of the parent parent.right = targetNode.right; } } else { root = targetNode.right; } } } } }