Java创建二叉搜索（排序）树

1.概念

二叉搜索树又称二叉排序树，它或者是一棵空树**，或者是具有以下性质的二叉树:

• 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
• 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
• 它的左右子树也分别为二叉搜索树
• 

2.操作-查找

3 操作-插入

4操作-删除

设待删除结点为 cur, 待删除结点的双亲结点为 parent

• 1. cur.left == null

1. cur 是 root，则 root = cur.right
2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.right
3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.right

• 2. cur.right == null

1. cur 是 root，则 root = cur.left
2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.left
3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.left

• 3. cur.left != null && cur.right != null

需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被
删除节点中，再来处理该结点的删除问题

代码实现：

class BinarySearchTree {

    static class BSNode {
        public int val;
        public BSNode left;
        public BSNode right;
        public BSNode(int val) {
            this.val = val;
        }
    }
    public BSNode root = null;

//查找结点 若找到返回该结点
    public BSNode search(int val) {
        if(root == null) return null;

        BSNode cur = root;
        while (cur != null){
            if (cur.val == val){
                return cur;
            }else if (cur.val > val){
                cur = cur.left;
            }else{
                cur = cur.right;
            }
        }
         return null;
    }


//插入节点
    public boolean insert(int val) {
        BSNode bsNode = new BSNode(val);
        if(root == null) {
            root = bsNode;
            return true;
        }
        BSNode cur = root;
        BSNode parent = null;
        while (cur != null) {
            if (val < cur.val) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        if(parent.val > val){
            parent.left = bsNode;
        }else{
            parent.right = bsNode;
        }
        return true;
    }
//删除节点
    public void remove(int val) {
        if(root == null) return;
        BSNode cur = root;
        BSNode parent = null;
        while (cur != null) {
            if(cur.val == val) {
                removeNode(parent,cur,val);
                return;
            }else if(cur.val < val) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }


    public void removeNode(BSNode parent,BSNode cur,int val) {
        if(cur.left == null) {
           if(cur == root){
                root = cur.right;
           }else if(cur == parent.left){
               parent.left = cur.right;
           }else if (cur == parent.right){
               parent.right = cur.left;
           }
        }else if(cur.right == null) {
            if(cur == root){
                root = cur.left;
            }else if(cur == parent.left){
                parent.left = cur.left;
            }else if (cur == parent.right){
                parent.right = cur.left;
            }
        }else {
            BSNode tgParent = cur;
            BSNode tg = tgParent.right;
            while(tg.left != null){
                tgParent = tg;
                tg = tg.left;
            }
            cur.val = tg.val;
            if(tg == tgParent.left){
                tgParent.left = tg.right;
            }else if (tg == tgParent.right){
                tgParent.right = tg.left;
            }

        }
    }
}
//测试
public class TestDemo {
    public static void main(String[] args) {
        BinarySearchTree binarySearchTree = new BinarySearchTree();
        binarySearchTree.insert(4);
        binarySearchTree.insert(3);
        binarySearchTree.insert(1);
        binarySearchTree.insert(15);
        binarySearchTree.insert(11);

        BinarySearchTree.BSNode ret = binarySearchTree.search(15);
        System.out.println(ret.val);
        System.out.println("==========");
        binarySearchTree.remove(15);

    }
}