Java数据结构——二叉排序树删除结点

在二叉排序树中删除结点共有三种情况：删除结点为叶子结点、删除结点有一颗子树、删除结点有两颗子树。

删除叶子结点操作：找到删除结点的父结点，判断叶子结点为左子结点还是右子结点，parent.left = null或者parent.right = null；

删除结点有一颗子树操作：判断要删除结点为父结点的左子结点还是右子结点，并判断删除结点有左子树还是右子树，parent.left = node.left；

删除结点有两颗子树操作：寻找删除结点左子树的最大值结点或者右子树的最小值结点，删除该结点，并且将该结点的值赋给删除结点

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        BinarySortTree bst = new BinarySortTree();
        int[] arr = {14, 55, 2, 45, 87, 100, 40, 13};
        for (int i = 0; i < arr.length; i++) {
            bst.add(new Node(arr[i]));
        }
        System.out.println("中序遍历的结果为：");
        bst.infixOrder();
//        删除结点有两颗子树
        bst.delNode(55);
//        删除结点有一颗子树
        bst.delNode(2);
//        删除结点为叶子结点
        bst.delNode(40);
        System.out.println("删除结点后，中序遍历结果为：");
        bst.infixOrder();
    }

}

//二叉排序树类
class BinarySortTree {
    private Node root;

    //查找要删除的结点
    public Node searchNode(int value) {
        if (root == null) {
            return null;
        } else {
            return root.searchNode(value);
        }
    }

    //查找要删除结点的父结点
    public Node searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            return root.searchParent(value);
        }
    }

    //    查找删除结点右子树的最小值
    public int delRightMin(Node node) {
        Node minNode = node;
        while (minNode.left != null) {
//            循环查找左子结点，最左结点为最小值
            minNode = minNode.left;
        }
//        删除最小结点
        delNode(minNode.value);
        return minNode.value;
    }

    //删除结点
    public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            Node node = searchNode(value);
            Node parent = searchParent(value);
            //如果找不到要删除的结点，退出方法
            if (node == null) {
                return;
            }
            //只有一个结点，该结点为根结点，则该结点一定会被删除
            if (root.left == null && root.right == null) {
                root = null;
                return;
            }
            //如果要删除的结点为叶子结点
            if (node.left == null && node.right == null) {
                //判断叶子结点为左子结点还是右子结点
                if (parent.left != null && parent.left.value == value) {
                    parent.left = null;
                    return;
                } else if (parent.right != null && parent.right.value == value) {
                    parent.right = null;
                    return;
                }
            } else if (node.left != null && node.right != null) {
//                要删除的结点有两颗子树
//                找到要删除结点右子树的最小结点
                node.value = delRightMin(node.right);
            } else {
//                要删除的结点有一颗子树
                if (root.value == value) {
//                    当删除结点为根结点
                    if (root.left != null) {
                        root = root.left;
                    } else {
                        root = root.right;
                    }
                } else if (parent.left == node) {
//                    删除结点为左子结点
                    if (node.left != null) {
//                       删除的结点有左子树
                        parent.left = node.left;
                    } else {
//                        删除的结点有右子树
                        parent.left = node.right;
                    }
                } else {
//                    删除的结点为右子结点
                    if (node.left != null) {
                        parent.right = node.left;
                    } else {
                        parent.right = node.right;
                    }
                }
            }
        }
    }

    //    添加结点
    public void add(Node node) {
        if (root == null) {
            root = node;
        } else {
            root.add(node);
        }
    }

    //    中序遍历
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉排序树为空，不能遍历");
        }
    }

}

//结点类
class Node {
    public int value;
    public Node left;
    public Node right;

    public Node(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }

    //查找结点，返回值为该结点，如果找不到，返回null
    public Node searchNode(int value) {
        if (value == this.value) {
            return this;
        } else if (value < this.value) {
            if (this.left == null) {
                return null;
            }
            return this.left.searchNode(value);
        } else {
            if (this.right == null) {
                return null;
            }
            return this.right.searchNode(value);
        }
    }

    //查找要删除结点的父结点
    public Node searchParent(int value) {
        if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
            return this;
        } else {
            if (this.left != null && value < this.value) {
                return this.left.searchParent(value);
            } else if (this.right != null && value >= this.value) {
                return this.right.searchParent(value);
            } else {
                return null;
            }
        }
    }

    //    添加结点
    public void add(Node node) {
        if (node == null) {
            return;
        }
        if (node.value < this.value) {
//            如果左子结点为空，则直接放在左子结点的位置上
            if (this.left == null) {
                this.left = node;
            } else {
//                左子结点不为空时，进行递归
                this.left.add(node);
            }
        } else {
            if (this.right == null) {
                this.right = node;
            } else {
                this.right.add(node);
            }
        }
    }

    //    中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

}

中序遍历的结果为：
Node{value=2}
Node{value=13}
Node{value=14}
Node{value=40}
Node{value=45}
Node{value=55}
Node{value=87}
Node{value=100}
删除结点后，中序遍历结果为：
Node{value=13}
Node{value=14}
Node{value=45}
Node{value=87}
Node{value=100}