手撕二叉搜索树代码

搜索树

概念

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

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

代码结构

public 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;
}

查找

思路：

若节点不为空：

• 如果根节点key == 查找key，返回true
• 如果根节点key > 查找key，在其左子树查找
• 如果根节点key < 查找key，在其右子树查找

否则，返回false

    public BSNode search(int val) {
        if(root == null) return null;

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

插入

1. 如果树为空，即根 == null，直接插入
2. 如果树不为空，按照查找逻辑确定插入位置，插入新节点

    public boolean insert(int val) {
        BSNode bsNode = new BSNode(val);
        if(root == null) {
            root = bsNode;
            return true;
        }
        BSNode cur = root;
        BSNode parent = new BSNode(val);
        while(cur != null) {
            if(cur.val == val) {
                return false;
            }
            parent = cur;
            if(cur.val > val) {
                cur = cur.left;
            }else {
                cur = cur.right;
            }
        }
        if(parent.val > val) {
            parent.left = bsNode;
        }else{
            parent.right = bsNode;
        }
        return true;
    }

删除

设待删除结点为 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
   （1） 需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题

    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 = root.right;
             }else {
                 if(cur == parent.left) {
                     parent.left = cur.right;
                 }
                 if(cur == parent.right) {
                     parent.right = cur.right;
                 }
             }
         }else if(cur.right == null) {
             if(cur == root) {
                 root = root.left;
             }else {
                 if(cur == parent.left) {
                     parent.left = cur.left;
                 }
                 if(cur == parent.right) {
                     parent.right = cur.left;
                 }
             }
         }else {
             BSNode targetParent = cur;
             BSNode target = cur.right;
             while (target.left != null) {
                 targetParent = target;
                 target = target.left;
             }
             //代码走到这里，target指向的 右边的最小值
             cur.val = target.val;

             if(target == targetParent.left) {
                 targetParent.left = target.right;
             }else {
                 targetParent.right = target.right;
             }
         }
    }

性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：logn
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：n/2