Java数据结构之二叉搜索树

1 二叉搜索树

1.1 概念

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

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

1.2 查找

1. 若根节点为空，则返回false
2. 如果根节点不为空：
   • 如果根节点key==查找key，返回true
   • 如果根节点key > 查找key，在其左子树查找
   • 如果根节点key==查找key，在其右子树查找

1.3 插入

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

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

1.5 代码实现

public class BinarySearchTree {

    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

    /**
     * 在搜索树中查找 key，如果找到，返回 key 所在的结点，否则返回 null
     *
     * @param key
     * @return
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if (key == cur.key) {
                return cur;
            } else if (key < cur.key) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        return null;
    }

    /**
     * 插入
     *
     * @param key
     * @return true 表示插入成功, false 表示插入失败
     */
    public boolean insert(int key) {
        if (root == null) {
            root = new Node(key);
            return true;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                return false;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        Node node = new Node(key);
        if (key < parent.key) {
            parent.left = node;
        } else {
            parent.right = node;
        }
        return true;
    }

    /**
     * 删除成功返回 true，失败返回 false
     *
     * @param key
     * @return
     */
    public boolean remove(int key) {
        if(root == null) {
            return false;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key > cur.key) {
                parent = cur;
                cur = cur.right;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
               removeNode(parent,cur);
               return true;
            }
        }


    }
    public void removeNode(Node parent,Node cur) {
        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.right;
            }
        }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 {
            Node target = cur.right;
            Node targetParent = cur;
            while(target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }

    }
}

1.6 性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2N
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2