算法-二叉搜索树(BST)

二叉搜索树 Binary Search Tree

高效，不仅可以查找数据；还可以高效的插入，删除数据-动态维护数据。

还可以很方便的回答很多数据之间的关系问题：

• min,max,floor,ceil,rank,select

二叉搜索树可以不用是完全的二叉搜索树。下面这个也是二叉搜索树：

由于二叉搜索树可以不是完全的二叉树，所以用数组表示不方便，我们采用的是用 Node 节点表示。

1. 插入元素

插入一个新节点，先比较该元素是否和根节点元素相同，如果相同，更新该节点的值，如果比根节点元素值小，则以构建左孩子节点，并返回该节点，否则构建右孩子节点，并返回值。

  public void insert(Key key, Value value) {
        root = insert(root, key, value);
    }

    // 向以node为根的二分搜索树中, 插入节点(key, value), 使用递归算法
    // 返回插入新节点后的二分搜索树的根
    private Node insert(Node node, Key key, Value value) {
        if (node == null) {
            count++;
            return new Node(key, value);
        }

        if (key.compareTo(node.key) == 0) {
            node.value = value;
        } else if (key.compareTo(node.key) < 0) {
            node.left = insert(node.left, key, value);
        } else {
            node.right = insert(node.right, key, value);
        }

        return node;
    }

2. 查找

先和根节点比较，如果相等则返回，如果比根节点小，与该节点左孩子比较，比根节点大，则与右孩子比较。如果左或右孩子都为空的话，则查找失败。

    // 查看二分搜索树中是否存在键key
    public boolean contain(Key key) {
        return contain(root, key);
    }

    // 在二分搜索树中搜索键key所对应的值。如果这个值不存在, 则返回null
    public Value search(Key key) {
        return search(root, key);
    }

    // 查看以node为根的二分搜索树中是否包含键值为key的节点, 使用递归算法
    private boolean contain(Node node, Key key) {
        if (node == null) {
            return false;
        }

        if (key.compareTo(node.key) == 0) {
            return true;
        } else if (key.compareTo(node.key) < 0) {
            return contain(node.left, key);
        } else {
            return contain(node.right, key);
        }
    }

    // 在以node为根的二分搜索树中查找key所对应的value, 递归算法
    // 若value不存在, 则返回NULL
    private Value search(Node node, Key key) {
        if (node == null) {
            return null;
        }

        if (key.compareTo(node.key) == 0) {
            return node.key;
        } else if (key.compareTo(node.key) < 0) {
            return search(node.left, key);
        } else {
            return search(node.right, key);
        }
    }

3. 遍历

3.1 前序遍历

    // 二分搜索树的前序遍历
    public void preOrder() {
        preOrder(root);
    }

    private void preOrder(Node node) {
        if (node != null) {
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

3.2 中序遍历

 // 二分搜索树的中序遍历
    public void inOrder() {
        inOrder(root);
    }

    private void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left);
            System.out.println(node.key);
            inOrder(node.right);
        }
    }

3.3 后序遍历

// 二分搜索树的后序遍历
    public void postOrder() {
        postOrder(root);
    }

    private void postOrder(Node node) {
        if (node != null) {
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.key);
        }
    }

3.4 层序遍历

// 二分搜索树的层序遍历
    public void levelOrder() {
        LinkedList<Node> list = new LinkedList<Node>();
        list.add(root);
        while (!list.isEmpty()) {
            Node node = list.removeFirst();

            System.out.println(node.key);

            if (node.left != null)
                list.add(node.left);
            if (node.right != null)
                list.add(node.right);
        }
    }

4. 取得最小值和最大值

二叉搜索树中的最小值就是一直寻找根节点的左孩子，直到该左孩子为空，则该节点就是最小值；最大值就是一直寻找根节点的右孩子，直到该右孩子为空，该节点就是最大值。

// 寻找二分搜索树的最小的键值
    public Key minimum(){
        assert count != 0;
        Node minNode=minimum(root);
        return minNode.key;
    }

    private Node minimum(Node node) {
        if (node.left ==null){
            return node;
        }
        return minimum(node.left);
    }

    // 寻找二分搜索树的最大的键值
    public Key maximum(){
        assert count !=0;
        Node maxNode=maximum(root);
        return maxNode.key;
    }

    private Node maximum(Node node) {
        if (node.right == null){
            return node;
        }
        return maximum(node.right);
    }

5. 删除

5.1 删除最小值和最大值

找到最小值，如果该最小值的右孩子不为空的话，把右孩子移上来；找到最大值，如果该节点的左孩子不空的话，则把左孩子移上来。

// 从二分搜索树中删除最小值所在节点
    public void removeMin(){
        if (root !=null){
            root=removeMin(root);
        }
    }

    private Node removeMin(Node node) {
        if (node.left == null){
            Node nodeRight=node.right;
            node.right=null;
            count--;
            return nodeRight;
        }
        node.left=removeMin(node.left);
        return node;
    }

    // 从二分搜索树中删除最大值所在节点
    public void removeMax(){
        if (root != null){
            root=removeMax(root);
        }
    }

    private Node removeMax(Node node) {
        if (node.right == null){
            Node nodeLeft=node.left;
            node.left=null;
            count--;
            return nodeLeft;
        }
        node.right=removeMax(node.right);
        return node;
    }

5.2 删除任意节点的值

如果要删除的节点只有左孩子，直接把左孩子移上去；如果要删除的节点只有右孩子，直接把右孩子移上去，如果要删除的节点既有左孩子又有右孩子，则选择右孩子中最小的，或者做孩子中最大的。

 // 从二分搜索树中删除键值为key的节点
    public void remove(Key key){
        root = remove(root, key);
    }

    // 删除掉以node为根的二分搜索树中键值为key的节点, 递归算法
    // 返回删除节点后新的二分搜索树的根
    private Node remove(Node node, Key key) {
        //未找到
        if(node==null){
            return null;
        }
        if (key.compareTo(node.key)<0){
            node.left=remove(node.left,key);
            return node;
        }else if (key.compareTo(key)>0){
            node.right=remove(node.right,key);
            return node;
        }else {
            // 待删除节点左子树为空的情况
            if (node.left == null){
                Node rightNode=node.right;
                node.right=null;
                count--;
                return rightNode;
            }
            // 待删除节点右子树为空的情况
            if (node.right==null){
                Node leftNode=node.left;
                node.left=null;
                count--;
                return leftNode;
            }

            Node successor=new Node(minimum(node.right));
            successor.right=removeMin(node.right);
            successor.left=node.left;

            node.left=node.right=null;
            count--;
            return successor;
        }
    }