二叉搜索树 Java实现

class Node<T extends Comparable> {
    
    
    T val;
    Node<T> left;
    Node<T> right;
    Node<T> parent;

    public Node() {
    
    
    }

    public Node(T val) {
    
    
        this.val = val;
    }

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

public class BinarySearchTree<T extends Comparable> {
    
    

    private Node<T> root;

    /*插入*/
    public void insertKV(T val) {
    
    
        if(root == null) {
    
    
            root = new Node<T>(val);
            return;
        }
        Node current = root;
        Node parten = root;
        boolean flag = true;
        while (current != null) {
    
    
            parten = current;
            if(current.val.compareTo(val) >= 0) {
    
    
                current = current.left;
                flag = true;
            }else {
    
    
                current = current.right;
                flag = false;
            }
        }
        Node<T> tNode = new Node<>(val);
        if(flag) {
    
    
            parten.left = tNode;
        }else {
    
    
            parten.right = tNode;
        }
        tNode.parent = parten;
    }

    /*查询*/
    public Node<T> search(T val) {
    
    
        Node<T> current = root;
        while (true) {
    
    
            if (current == null) {
    
    
                return null;
            }
            T val1 = current.val;
            int i = current.val.compareTo(val);
            if(i == 0) {
    
    
                return current;
            }
            current = i > 0 ? current.left : current.right;
        }
    }

    /*删除*/
    public boolean delete(T val) {
    
    
        Node<T> current = search(val);
        if(current == null) {
    
    
            return false;
        }
        Node<T> parent = current.parent;
        Node<T> successor;
        /*删除叶子节点*/
        if(current.left == null && current.right == null) {
    
    
            successor = null;
        /*删除只有左节点或者右节点*/
        }else if(current.left == null || current.right == null) {
    
    
            successor = current.left == null ? current.right : current.left;
        /*删除包含双节点*/
        }else {
    
    
            successor = getSuccessor(current);
            successor.parent = current.parent;
            successor.left = current.left;
            successor.right = current.right;
        }

        if(current.parent.left == current) {
    
    
            current.parent.left = successor;
        }else {
    
    
            current.parent.right = successor;
        }
        return true;
    }

    /*找到继承节点*/
    private Node<T> getSuccessor(Node<T> node) {
    
    
        Node<T> current = node.right;
        while (true) {
    
    
            if(current.left == null) {
    
    
                return current;
            }else {
    
    
                current = current.left;
            }
        }
    }

    public static void main(String[] args) {
    
    
        BinarySearchTree<Integer> searchTree = new BinarySearchTree<>();
        searchTree.insertKV(10);
        searchTree.insertKV(8);
        searchTree.insertKV(12);
        searchTree.insertKV(7);
        searchTree.insertKV(9);
        searchTree.insertKV(11);
        searchTree.insertKV(15);
        searchTree.insertKV(13);
        System.out.println(searchTree.delete(12));
        System.out.println(111);
    }
}