二叉搜索树(BST)的增删改

维基百科关于二叉搜索树的介绍

二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树。

在二叉查找树删去一个结点，分三种情况讨论：

1. 若*p结点为叶子结点，即PL（左子树）和PR（右子树）均为空树。由于删去叶子结点不破坏整棵树的结构，则只需修改其双亲结点的指针即可。
2. 若*p结点只有左子树PL或右子树PR，此时只要令PL或PR直接成为其双亲结点*f的左子树（当*p是左子树）或右子树（当*p是右子树）即可，作此修改也不破坏二叉查找树的特性。
3. 若*p结点的左子树和右子树均不空。在删去*p之后，为保持其它元素之间的相对位置不变，可按中序遍历保持有序进行调整，可以有两种做法：其一是令*p的左子树为*f的左/右（依*p是*f的左子树还是右子树而定）子树，*s为*p左子树的最右下的结点，而*p的右子树为*s的右子树；其二是令*p的直接前驱（in-order predecessor）或直接后继（in-order successor）替代*p，然后再从二叉查找树中删去它的直接前驱（或直接后继）。

package com.example;

public class BST {
    static class Node{
        int value;
        Node left;
        Node right;
    }
    public static void main(String[] args){
        int[] datas = new int[]{21, 12, 1, 14, 50, 24, 70};
        Node node = null;
        for(int i = 0; i < datas.length; i++){
            node = insertBST(node, datas[i]);
        }
        travelBST(node);
        Node node1 = deleteBST(node, 21);
        System.out.println("\nafter delete 21:");
        travelBST(node1);
        Node node2 = deleteBST(node, 50);
        System.out.println("\nafter delete 50:");
        travelBST(node2);
    }

    static Node insertBST(Node root, int key){
        if(root == null){
            Node node = new Node();
            node.value = key;
            return node;
        }
        if(key < root.value){
            Node node = insertBST(root.left, key);
            root.left = node;
        }
        if(key > root.value) {
            Node node = insertBST(root.right, key);
            root.right = node;
        }
        return root;
    }

    static void travelBST(Node root){
        if(root == null){
            return;
        }else {
            if (root.left != null) {
                travelBST(root.left);
            }
            System.out.print(root.value + ", ");
            if (root.right != null) {
                travelBST(root.right);
            }
        }
    }

    static Node deleteBST(Node node, int key){
        if(node == null){
            return node;
        }
        if (node.value == key) {
            return delete(node);
        } else if (key < node.value) {
            node.left = deleteBST(node.left, key);
        } else{
            node.right = deleteBST(node.right, key);
        }
        return node;
    }

    static Node delete(Node node){
        if(node.left == null && node.right == null){
            return null;
        }else if(node.left == null){
            return node.right;
        }else if(node.right == null){
            return node.left;
        }else {
            Node pre = node;
            Node s = node.left;
            while (s.right != null){
                pre = s;
                s = s.right;
            }
            node.value = s.value;
            if(pre != node){
                pre.right = s.left;
            }else {
                pre.left = s.left;
            }
        }
        return node;

    }
}