int[] arrs = {5,2,1,4,3,9,7,6,8};

int[] arrs = {1,2,3,4,5,6,7,8,9};

package Algorithm;
public class BinarySearchTree {
    Node root;  //定義根節(jié)點
    //結(jié)點插入方法
    public void insert(int value) {
        if (root == null) {        //1.如果樹是空樹，插入節(jié)點就直接放入到根結(jié)點
            root = new Node(value);
        } else {     //如果樹不是空樹，則插入的數(shù)字于根結(jié)點的數(shù)字進行比較
            //2.如果插入的值小于于結(jié)點的數(shù)字，則往左子樹插入
            Node node = root;     //聲明一個游標(biāo)結(jié)點，開始指向根節(jié)點
            while (true) {       //并且再次和待插入的執(zhí)行左子結(jié)點進行比較，直到找到插入的位置
                if (value < node.value) {      //如果插入的值小于于結(jié)點的數(shù)字，則往左子樹插入
                    //2.1如果左子結(jié)點沒有元素就插入到左子結(jié)點中
                    if (node.left == null) {
                        node.left = new Node(value);
                        break;      //如果找到插入的位置，則跳出while循環(huán)
                    } else {         //如果左子結(jié)點有元素，就可以設(shè)計一個引用(游標(biāo))指向左子節(jié)點，并且再次和待插入的執(zhí)行左子結(jié)點進行比較，直到找到插入的位置
                        //游標(biāo)指向左子節(jié)點
                        node = node.left;
                    }
                } else {      //如果插入的值大于結(jié)點的數(shù)字，則往右子樹插入
                    //判斷右子結(jié)點是否存在值，如果不存在則直接插入
                    if (node.right == null) {
                        node.right = new Node(value);
                        break;
                    } else {     //判斷右子結(jié)點是否存在值，如果存在則通過一個引用指向右子結(jié)點繼續(xù)和待插入的值進行比較，直到找到插入的位置
                        //游標(biāo)指向右子節(jié)點
                        node = node.right;
                    }
                }
            }
        }
    }
    //定義左右結(jié)點常量
    public static final int LEFT = 0; //左子節(jié)點
    public static final int RIGHT = 1; //右子節(jié)點
    //結(jié)點查找方法
    public void deleteNode(int value) {
        //定義游標(biāo)從根節(jié)點開始查詢
        Node node = root;
        //定義目標(biāo)結(jié)點
        Node target = null;
        //定義目標(biāo)結(jié)點的父類結(jié)點
        Node parent = null;
        //目標(biāo)結(jié)點的類型為，左子節(jié)點或者右子節(jié)點
        int nodeType = 0; //0代表左子節(jié)點 1代表右子節(jié)點

        while (node != null) { //游標(biāo)不為空，如果為空則沒有子節(jié)點，無法刪除
            if (node.value == value) { //如果目標(biāo)結(jié)點的值和需要刪除結(jié)點的值相同
                //找到結(jié)點
                target = node;
                break;
            } else if (value < node.value) {    //如果值不同，則判斷目標(biāo)結(jié)點值是否小于node結(jié)點
                //保存父類結(jié)點
                parent = node;
                //游標(biāo)指向左子節(jié)點
                node = node.left;
                nodeType = LEFT;
            } else { //如果值不同，且目標(biāo)結(jié)點值大于node結(jié)點
                //保存父類結(jié)點
                parent = node;
                //游標(biāo)指向右子節(jié)點
                node = node.right;
                nodeType = RIGHT;
            }
        }
        //如果沒找到需要刪除的目標(biāo)結(jié)點
        if (target==null){
            System.out.println("沒有找到要刪除的結(jié)點");
            return;
        }
        //刪除結(jié)點的三種情況
        if (target.left == null && target.right == null) {   //情況1：待刪除的結(jié)點沒有子結(jié)點

            if (parent==null){      //刪除的結(jié)點沒有子結(jié)點
                //將root設(shè)置為null即可
                root=null;
                return;
            }
            //判斷目標(biāo)的結(jié)點是左子節(jié)點還是右子節(jié)點
            if (nodeType == LEFT) {
                //將父類的左子節(jié)點設(shè)置為null
                parent.left = null;
            } else {
                //將父類的右子節(jié)點設(shè)置為null
                parent.right = null;
            }
        } else if (target.left != null && target.right != null) {   //情況2：待刪除的結(jié)點有2個子節(jié)點
            //兩個子節(jié)點，從target右子樹查找最小的值
            Node min=target.right;
            //遍歷左子樹
            while (min.left!=null){
                min = min.left;
            }
            //將最小的結(jié)點進行刪除
            deleteNode(min.value);
            //將待刪除的結(jié)點替換成最小的結(jié)點的值
            target.value= min.value;
        }else { //情況3：待刪除的結(jié)點有1個子節(jié)點
            //刪除結(jié)點是根節(jié)點
            if (parent==null){
                if (target.left!=null){ //判斷是左子節(jié)點還是右子節(jié)點有值
                    root=target.left;   //根節(jié)點=目標(biāo)左子結(jié)點
                }else {
                    root=target.right;  //根節(jié)點=目標(biāo)右子結(jié)點
                }
            }
            //只有一個子節(jié)點
            if (nodeType==LEFT){    //如果是左子節(jié)點
                if (target.left!=null){
                    //將父類的左子節(jié)點，指向待刪除結(jié)點的左子節(jié)點
                    parent.left=target.left;
                }else { //如果是右子節(jié)點
                    //將父類的左子節(jié)點，指向待刪除結(jié)點的右子節(jié)點
                    parent.left=target.right;
                }
            }else {
                if (target.right!=null){
                    //將父類的右子節(jié)點，指向待刪除結(jié)點的左子節(jié)點
                    parent.right=target.left;
                }else { //如果是右子節(jié)點
                    //將父類的右子節(jié)點，指向待刪除結(jié)點的右子節(jié)點
                    parent.right=target.right;
                }
            }
        }
    }
    //實現(xiàn)中序遍歷
    public void midTraversal(Node node) {
        if (node == null) {  //進行判斷結(jié)點不能為空，如果為空則退出
            return;
        } else {     //如果結(jié)點不為null，則執(zhí)行下列遍歷語句
            //首先，遍歷左節(jié)點
            midTraversal(node.left);
            //打印根節(jié)點
            System.out.print(node.value + ",");
            //最后遍歷右子結(jié)點
            midTraversal(node.right);
        }
    }
    //創(chuàng)建一個結(jié)點類
    public static class Node {
        int value;  //存儲值
        Node left;  //左子樹
        Node right; //右子樹
        // 帶參構(gòu)造方法，傳入value賦值
        public Node(int value) {
            this.value = value;
        }
    }
}

package Algorithm;
public class TestBST {
    public static void main(String[] args) {
        int[] arrs = {5, 2, 1, 4, 3, 9, 7, 6, 8};
        //創(chuàng)建二叉查詢樹
        BinarySearchTree tree = new BinarySearchTree();
        //將數(shù)組中的元素構(gòu)造成二叉查詢樹
        for (int i = 0; i < arrs.length; i++) {
            tree.insert(arrs[i]);
        }
        //刪除結(jié)點
        tree.deleteNode(20);
        //中序遍歷根結(jié)點
        tree.midTraversal(tree.root);
    }
}