本文详细介绍了二分搜索树中节点删除的多种情况，包括删除最小值、最大值及任意元素节点的方法。探讨了如何处理有左右孩子的节点删除难题，通过示例代码展示了具体的实现过程。
删除二分搜索树的节点
一、删除二分搜索树的最小值和最大值
1.先找到二分搜索树的最小值和最大值
最小值：二叉树中的最左侧的元素（不存在左孩子的节点）
最大值：二叉树中的最右侧的元素（不存在右孩子的节点）
2.再删除二分搜索树的最小值和最大值
1.当要删除的节点为叶子节点时，直接删除即可
2.当要删除的节点不是叶子节点时，将该节点删除，删除后将其整个右子树变为根节点的左子树即可
代码实现：
BST.java
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class BST<E extends Comparable<E>> {
private class Node{
public E e;
public Node left, right;
public Node(E e){
this.e = e;
left = null;
right = null;
}
}
private Node root;
private int size;
public BST(){
root = null;
size = 0;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
// 向二分搜索树中添加新的元素e
public void add(E e){
root = add(root, e);
}
// 向以node为根的二分搜索树中插入元素e，递归算法
// 返回插入新节点后二分搜索树的根
private Node add(Node node, E e){
if(node == null){
size ++;
return new Node(e);
}
if(e.compareTo(node.e) < 0)
node.left = add(node.left, e);
else if(e.compareTo(node.e) > 0)
node.right = add(node.right, e);
return node;
}
// 看二分搜索树中是否包含元素e
public boolean contains(E e){
return contains(root, e);
}
// 看以node为根的二分搜索树中是否包含元素e, 递归算法
private boolean contains(Node node, E e){
if(node == null)
return false;
if(e.compareTo(node.e) == 0)
return true;
else if(e.compareTo(node.e) < 0)
return contains(node.left, e);
else // e.compareTo(node.e) > 0
return contains(node.right, e);
}
// 二分搜索树的前序遍历
public void preOrder(){
preOrder(root);
}
// 前序遍历以node为根的二分搜索树, 递归算法
private void preOrder(Node node){
if(node == null)
return;
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
// 二分搜索树的非递归前序遍历
public void preOrderNR(){
Stack<Node> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
Node cur = stack.pop();
System.out.println(cur.e);
if(cur.right != null)
stack.push(cur.right);
if(cur.left != null)
stack.push(cur.left);
}
}
// 二分搜索树的中序遍历
public void inOrder(){
inOrder(root);
}
// 中序遍历以node为根的二分搜索树, 递归算法
private void inOrder(Node node){
if(node == null)
return;
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
// 二分搜索树的后序遍历
public void postOrder(){
postOrder(root);
}
// 后序遍历以node为根的二分搜索树, 递归算法
private void postOrder(Node node){
if(node == null)
return;
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
// 二分搜索树的层序遍历
public void levelOrder(){
Queue<Node> q = new LinkedList<>();
q.add(root);
while(!q.isEmpty()){
Node cur = q.remove();
System.out.println(cur.e);
if(cur.left != null)
q.add(cur.left);
if(cur.right != null)
q.add(cur.right);
}
}
// 寻找二分搜索树的最小元素（新增代码）
public E minimum(){
if(size == 0) //二叉树中没有元素
throw new IllegalArgumentException("BST is empty");
Node minNode = minimum(root);
return minNode.e;
}
// 返回以node为根的二分搜索树的最小值所在的节点（新增代码）
private Node minimum(Node node){
if( node.left == null ) //最左侧为空的节点
return node;
return minimum(node.left);
}
// 寻找二分搜索树的最大元素（新增代码）
public E maximum(){
if(size == 0)
throw new IllegalArgumentException("BST is empty");
return maximum(root).e;
}
// 返回以node为根的二分搜索树的最大值所在的节点（新增代码）
private Node maximum(Node node){
if( node.right == null )
return node;
return maximum(node.right);
}
// 从二分搜索树中删除最小值所在节点, 返回最小值（新增代码）
public E removeMin(){
E ret = minimum();
root = removeMin(root); //从root 开始尝试删除最小节点
return ret;
}
// 删除掉以node为根的二分搜索树中的最小节点（新增代码）
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){
if(node.left == null){ //node 没有左孩子的情况
Node rightNode = node.right; //保存当前节点的右子树
node.right = null; //将当前的node节点从二叉树中脱离关系
size --;
return rightNode; //使右孩子成为新的节点
}
node.left = removeMin(node.left);//node 有左孩子的情况，删除掉当前树的左子树对应的最小值
return node;
}
// 从二分搜索树中删除最大值所在节点（新增代码）
public E removeMax(){
E ret = maximum();
root = removeMax(root);
return ret;
}
// 删除掉以node为根的二分搜索树中的最大节点（新增代码）
// 返回删除节点后新的二分搜索树的根
private Node removeMax(Node node){
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size --;
return leftNode;
}
node.right = removeMax(node.right);
return node;
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
generateBSTString(root, 0, res);
return res.toString();
}
// 生成以node为根节点，深度为depth的描述二叉树的字符串
private void generateBSTString(Node node, int depth, StringBuilder res){
if(node == null){
res.append(generateDepthString(depth) + "null\n");
return;
}
res.append(generateDepthString(depth) + node.e +"\n");
generateBSTString(node.left, depth + 1, res);
generateBSTString(node.right, depth + 1, res);
}
private String generateDepthString(int depth){
StringBuilder res = new StringBuilder();
for(int i = 0 ; i < depth ; i ++)
res.append("--");
return res.toString();
}
}
Main.java
import java.util.ArrayList;
import java.util.Random;
public class Main {
public static void main(String[] args) {
BST<Integer> bst = new BST<>();
Random random = new Random();
int n = 1000; //向二叉树中添加1000个元素
// test removeMin
for(int i = 0 ; i < n ; i ++)
bst.add(random.nextInt(10000)); //随机数范围0-10000
ArrayList<Integer> nums = new ArrayList<>();
while(!bst.isEmpty()) //bst 不为空的话，
nums.add(bst.removeMin()); //从 bst 中取出元素，将取出元素的最小值添加到 nums 的ArrayList中
System.out.println(nums);
for(int i = 1 ; i < nums.size() ; i ++)
if(nums.get(i - 1) > nums.get(i))
throw new IllegalArgumentException("Error!");
System.out.println("removeMin test completed.");
// test removeMax
for(int i = 0 ; i < n ; i ++)
bst.add(random.nextInt(10000));
nums = new ArrayList<>();
while(!bst.isEmpty())
nums.add(bst.removeMax());
System.out.println(nums);
for(int i = 1 ; i < nums.size() ; i ++)
if(nums.get(i - 1) < nums.get(i))
throw new IllegalArgumentException("Error!");
System.out.println("removeMax test completed.");
}
}
输出：
二、删除二分搜索树的任意元素
1.删除只有左孩子的节点：节点删除之后，将左孩子所在的二叉树取代其位置；连在原来父亲元素右节点的位置
2.删除只有右孩子的节点：节点删除之后，将右孩子所在的二叉树取代其位置；连在原来父亲元素左节点的位置
3.难点：删除有左右孩子的节点（删除左右都有孩子的节点d）
在图中，要删除58，就是要找到58的替代节点，找 58 （d）的后继：所有元素中，离 58 最近的且比 58 大的节点，即图中的 59 (s)【即右子树中的最小值】
示例代码：BST.java
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class BST<E extends Comparable<E>> {
private class Node{
public E e;
public Node left, right;
public Node(E e){
this.e = e;
left = null;
right = null;
}
}
private Node root;
private int size;
public BST(){
root = null;
size = 0;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
// 向二分搜索树中添加新的元素e
public void add(E e){
root = add(root, e);
}
// 向以node为根的二分搜索树中插入元素e，递归算法
// 返回插入新节点后二分搜索树的根
private Node add(Node node, E e){
if(node == null){
size ++;
return new Node(e);
}
if(e.compareTo(node.e) < 0)
node.left = add(node.left, e);
else if(e.compareTo(node.e) > 0)
node.right = add(node.right, e);
return node;
}
// 看二分搜索树中是否包含元素e
public boolean contains(E e){
return contains(root, e);
}
// 看以node为根的二分搜索树中是否包含元素e, 递归算法
private boolean contains(Node node, E e){
if(node == null)
return false;
if(e.compareTo(node.e) == 0)
return true;
else if(e.compareTo(node.e) < 0)
return contains(node.left, e);
else // e.compareTo(node.e) > 0
return contains(node.right, e);
}
// 二分搜索树的前序遍历
public void preOrder(){
preOrder(root);
}
// 前序遍历以node为根的二分搜索树, 递归算法
private void preOrder(Node node){
if(node == null)
return;
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
// 二分搜索树的非递归前序遍历
public void preOrderNR(){
Stack<Node> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
Node cur = stack.pop();
System.out.println(cur.e);
if(cur.right != null)
stack.push(cur.right);
if(cur.left != null)
stack.push(cur.left);
}
}
// 二分搜索树的中序遍历
public void inOrder(){
inOrder(root);
}
// 中序遍历以node为根的二分搜索树, 递归算法
private void inOrder(Node node){
if(node == null)
return;
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
// 二分搜索树的后序遍历
public void postOrder(){
postOrder(root);
}
// 后序遍历以node为根的二分搜索树, 递归算法
private void postOrder(Node node){
if(node == null)
return;
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
// 二分搜索树的层序遍历
public void levelOrder(){
Queue<Node> q = new LinkedList<>();
q.add(root);
while(!q.isEmpty()){
Node cur = q.remove();
System.out.println(cur.e);
if(cur.left != null)
q.add(cur.left);
if(cur.right != null)
q.add(cur.right);
}
}
// 寻找二分搜索树的最小元素
public E minimum(){
if(size == 0)
throw new IllegalArgumentException("BST is empty!");
return minimum(root).e;
}
// 返回以node为根的二分搜索树的最小值所在的节点
private Node minimum(Node node){
if(node.left == null)
return node;
return minimum(node.left);
}
// 寻找二分搜索树的最大元素
public E maximum(){
if(size == 0)
throw new IllegalArgumentException("BST is empty");
return maximum(root).e;
}
// 返回以node为根的二分搜索树的最大值所在的节点
private Node maximum(Node node){
if(node.right == null)
return node;
return maximum(node.right);
}
// 从二分搜索树中删除最小值所在节点, 返回最小值
public E removeMin(){
E ret = minimum();
root = removeMin(root);
return ret;
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// 从二分搜索树中删除最大值所在节点
public E removeMax(){
E ret = maximum();
root = removeMax(root);
return ret;
}
// 删除掉以node为根的二分搜索树中的最大节点
// 返回删除节点后新的二分搜索树的根
private Node removeMax(Node node){
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size --;
return leftNode;
}
node.right = removeMax(node.right);
return node;
}
// 从二分搜索树中删除元素为e的节点（新增代码）
public void remove(E e){
root = remove(root, e);
}
// 删除掉以node为根的二分搜索树中值为e的节点, 递归算法（新增代码）
// 返回删除节点后新的二分搜索树的根
private Node remove(Node node, E e){//（新增代码）
if( node == null )
return null;
if( e.compareTo(node.e) < 0 ){ //要删除的元素 e 要比 node上的元素 e 要小的话
node.left = remove(node.left , e); //到左子树中删除
return node;
}
else if(e.compareTo(node.e) > 0 ){//要删除的元素 e 要比 node上的元素 e 要大的话
node.right = remove(node.right, e); //到右子树中删除
return node;
}
else{ // e.compareTo(node.e) == 0
// 待删除节点左子树为空的情况//（新增代码）
if(node.left == null){
Node rightNode = node.right; //保存右子树内容
node.right = null; //将 右子树与二叉树断开关系
size --;
return rightNode; //返回原来元素的右孩子【右子树的根节点】
}
// 待删除节点右子树为空的情况
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size --;
return leftNode;
}
// 待删除节点左右子树均不为空的情况//（新增代码）
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
// 用这个节点顶替待删除节点的位置
Node successor = minimum(node.right); //要找到 node 节点的后继
successor.right = removeMin(node.right);
//从node.right中removeMin 掉其中的最小节点，根节点返回作为后继的右子树
successor.left = node.left; // successor 替代原来的 node 节点
node.left = node.right = null; //node 节点与二分搜索树脱离关系
return successor;
}
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
generateBSTString(root, 0, res);
return res.toString();
}
// 生成以node为根节点，深度为depth的描述二叉树的字符串
private void generateBSTString(Node node, int depth, StringBuilder res){
if(node == null){
res.append(generateDepthString(depth) + "null\n");
return;
}
res.append(generateDepthString(depth) + node.e +"\n");
generateBSTString(node.left, depth + 1, res);
generateBSTString(node.right, depth + 1, res);
}
private String generateDepthString(int depth){
StringBuilder res = new StringBuilder();
for(int i = 0 ; i < depth ; i ++)
res.append("--");
return res.toString();
}
}
补充：
总结：
1.二分搜索树的顺序性：放入.二分搜索树的元素都是有序的；
2.floor 和 ceil:floor:比45小的最大元素；ceil:比45大的最小元素【这两个可以不在二分搜索树中】
3.rank ：58 在整个树中所有的元素里排第几
4.select:rank 的反向操作
5.维护 size 的二分搜索树
6.支持重复元素的二分搜索树（定义左子树的节点 <= 父节点的值）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
