查找系列合集-二叉查找树BST

一、 二叉树

1. 什么是二叉树？

在计算机科学中，二叉树是每个结点最多有两个子树的树结构。

通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

二叉树常被用于实现二叉查找树和二叉堆。

2. 二叉树是一个递归的定义

（1）根结点为空则定义该二叉树为空

（2）一个根结点，可以导出一棵完整的二叉树，而它的左孩子或者右孩子，同样可以是代表一棵完整二叉树的根结点，不论它是否为空。即左子树和右子树同样为二叉树。

3. 二叉堆

（1）二叉堆一般由数组实现，分为大根堆和小根堆，可以实现O（1）的时间查找最大值（最小值）。

（2）插入一个元素O（logN）,先插到末尾，然后通过swim操作上浮调整，保持堆结构

（3）删除一个元素O（logN）,先把头尾元素交换，删去尾，对头进行sink操作下沉调整，保持堆结构。

（4）详情可见另外一篇博客排序系列及其拓展优化 中的基于堆的优先队列实现

二、 基于数组的二叉查找树

1. 保证数组有序

2. 通过【二分】的方法实现对数时间内查找

3. 由于是数组，要保持元素个数变化后数组依然有序，则插入和删除必然导致有一段元素需要整体移动，因此代价是O（N）

4. 基于数组的二叉查找树和堆的区别？为什么堆能保持对数级别的插入和删除？

（1）二叉查找树和堆虽然都基于数组，但是前者的数组有序，而后者只是保持堆结构（堆结构只是顶头元素是最值但是不是整体有序）

（2）二叉查找树可以查找任意关键字的元素，而堆是为了保持顶头元素的最值特性并不具备优秀的查找功能。

5. 代码实现

package search;

import java.util.Random;
/*
 * 基于有序数组的二叉搜索树
 * */
public class BinarySearchST<Key extends Comparable<Key> , Value> {
    private Key[] keys; //键
    private Value[] vals; //值
    private int N;// 当前使用容量
    
    public BinarySearchST(int capacity) {
        keys = (Key[]) new Comparable[capacity];
        vals = (Value[]) new Object[capacity];
    }
    
    public int size() {
        return N;
    }
    //根据键来查找对应值
    public Value get(Key key) {
        //找出该键在数组中的下标
        int pos = rank(key);
        //如果找到的下标在范围内并且确实是这个键，说明找到了
        if(pos < N && keys[pos].compareTo(key) == 0) {
            return vals[pos];
        }
        else return null;//否则没有找到，返回空
    }
    //二分法查找键的位置
    public int rank(Key key) {
        int lo = 0, hi = N - 1;
        //二分查找
        while(lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if(keys[mid].compareTo(key) > 0) {
                hi = mid - 1;
            }
            else if(keys[mid].compareTo(key) < 0 ) {
                lo = mid + 1;
            }
            else {
                return mid;
            }
        }
        //如果找不到 之前一步lo必定等于hi， 看这个数字是大于还是小于，不论怎样，lo的位置都代表如果这个数存在
        //它应该处于的位置
        return lo;
    }
    
    public void put(Key key, Value val) {
        int pos = rank(key);//先看这个键有木有
        //如果有只需要修改一下值就行了
        if(pos < N && keys[pos].compareTo(key) == 0) {
            vals[pos] = val;
        }
        //如果没有就新建一个键值对 插入
        //插入的位置正好是pos 那么pos之后的数都要后移一位
        //如果容量已满需要扩容
        for(int i=N-1; i>=pos; i--) {
            keys[i + 1] = keys[i];
            vals[i + 1] = vals[i];
        }
        //空出来的位置插入新键值对
        keys[pos] = key;
        vals[pos] = val;
        N++;
    }
    
    public void delete(Key key) {
        int pos = rank(key);//先看这个键有木有
        //如果有就删除 并且后移一位
        if(pos < N && keys[pos].compareTo(key) == 0) {
            for(int i=pos; i<N-1; i++) {
                keys[i] = keys[i+1];
                vals[i] = vals[i+1];
            }
            N--;
        }
        //如果没有就返回
        return;
    }
    
    public void show() {
        for(int i=0; i<N; i++) {
            System.out.println(keys[i].toString() + " : " + vals[i].toString());
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BinarySearchST<Integer, Integer> bs = new BinarySearchST<Integer , Integer>(20);
        Random r = new Random();
        for(int i=0; i<10; i++) {
            Integer t1 = new Integer(r.nextInt(1000));
            Integer t2 = new Integer(r.nextInt(1000));
            bs.put(t1, t2);
        }
        bs.show();
        System.out.println("size = " + bs.size());
        System.out.println("*********************");
        bs.put(999, 999);
        bs.put(555, 555);
        bs.show();
        System.out.println("size = " + bs.size());
        System.out.println("*********************");
        bs.delete(555);
        bs.delete(1024);
        bs.show();
        System.out.println("size = " + bs.size());
    }

}

三、 基于链表的二叉查找树BST

1. 结点结构

private class Node{
        private Key key;//键
        private Value val;//值
        private Node left , right;//左孩子和右孩子
        private int N ; //该子树的总结点个数
        public Node() {}
        public Node(Key key, Value val, int N) {
            this.key = key;
            this.val = val;
            this.N = N;
        }
    }

2. BST类结构

public class BST<Key extends Comparable<Key> , Value> {
    private Node root;
    private class Node{...}//结点内部类声明
    //一系列方法
    
}

3. 核心方法：增删改查

（1）查找

　　a. 基于二分

　　b. 利用树天生的递归特性，递归查找

    //根据键找值
    public Value get(Key key) {
        return get(root , key);
    }
    private Value get(Node x, Key key) {
        if(x == null) return null;
        int cmp = x.key.compareTo(key);
        if(cmp == 0) return x.val;
        else if(cmp > 0) return get(x.left , key);
        else return get(x.right , key);
    }

（2）插入

　　a. 插入从某种意义上包括了修改，因为改某一个键所对应的值只需要插入同键不同值即可。

　　b. 插入总是被插入到了某一个结点的空的左右子结点中

　　

public void put(Key key, Value val) {
        root = put(root , key, val);
    }
    private Node put(Node x , Key key, Value val) {
        //如果没有这个键就新增一个
        if(x == null) {
            return x = new Node(key , val, 1);
        }
        //沿途二分找键，遇到的根节点键大，则在其左子树递归查找，键小，在右子树递归查找，
        //直到找到相等或者发现根节点为空为止
        int cmp = x.key.compareTo(key);
        if(cmp > 0) {
            x.left = put(x.left , key, val);
        }
        else if(cmp < 0) {
            x.right = put(x.right , key , val);
        }
        else {
            x.val = val;
        }
        //沿途回溯更新结点的size  自底向上
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

（3）删除

　删除是BST的最复杂的操作，先考虑一下几种情况 ,假设被删除的结点记为z：

　　（a）z左右孩子均为空。这种情况十分简单，直接删除这个结点即可，正棵BST仍然有序

　　

　　（b）z有一个孩子不空。不妨假设右孩子不空，那么只需要把z.right 作为z的父节点x的新的孩子结点即可。

　　　　  比如结点x.right = z, 则只需要把x.right = z.right 即可，（x.left = z同理）BST有序性不变

　　

　　（c）z的左右孩子均不空。

• • 假设z的父节点为x，且x.left = z （x.right = z同理可得）
  • 首先把 z 暂存，存为结点 t
  • 找z的右子树的最小结点（该操作为deleteMin(Node x)），不妨设为y，则y.left必为空，并且满足t.left < y < t.right。也就是说，如果把y结点放到要删除的z结点的位置，树还是有序的
  • 把z结点指针指向y (z和y是同一结点), 把按照（b）情况删除结点z并返回z结点，注意经过b操作后，此时z的父节点与z的右孩子结点已经连接
  • 把z的左右孩子设置为t的左右孩子
  • x.left = z即可。
  • 若看不明白只需要记住加黑字体是该算法的主要思想，详情见代码。

 　　　　

　【代码实现】

    //删除一棵树的最小结点
    public void deleteMin() {
        root = deleteMin(root);
    }

    private Node deleteMin(Node x) {
        // TODO Auto-generated method stub
        if(x.left != null) {
            x.left = deleteMin(x.left);
            x.N = size(x.left) + size(x.right) + 1;
            return x;
        }
        return x.right;
    }
    
    public void delete(Key key) {
        root = delete(root , key);
    }
    public Node delete(Node x, Key key) {
        if(x ==  null) return null;
        int cmp = x.key.compareTo(key);
        if(cmp > 0) {
            x.left = delete(x.left , key);
        }
        else if(cmp < 0) {
            x.right = delete(x.right ,  key);
        }
        else {
            //找到要删除的结点了
            if(x.left == null) return x.right;
            if(x.right == null) return x.left;
            
            Node t = x;
            x = minK(t.right);
            x.right = deleteMin(t.right);
            x.left = t.left;
        }
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

　4. 其他操作

• 　public Key ceiling(Key key)   //返回大于等于key的最大值所在结点

• 　public Keyfloor(Key key)  //返回小于等于key的最大值所在结点

• public Key select(int k) //查找排名为K的键(树中恰好有K个小于他的键)
• public ...... //其他操作

四、 BST数据结构源码

package search;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;

public class BST<Key extends Comparable<Key> , Value> {
    private Node root;
    //结点内部类声明
    private class Node{
        private Key key;//键
        private Value val;//值
        private Node left , right;//左孩子和右孩子
        private int N ; //该子树的总结点个数
        public Node() {}
        public Node(Key key, Value val, int N) {
            this.key = key;
            this.val = val;
            this.N = N;
        }
        
    }
    public int size(){
        return size(root);
    }
    private int size(Node x) {
        if(x == null) return 0;
        return x.N;
    }
    //根据键找值
    public Value get(Key key) {
        return get(root , key);
    }
    private Value get(Node x, Key key) {
        if(x == null) return null;
        int cmp = x.key.compareTo(key);
        if(cmp == 0) return x.val;
        else if(cmp > 0) return get(x.left , key);
        else return get(x.right , key);
    }
    public void put(Key key, Value val) {
        root = put(root , key, val);
    }
    private Node put(Node x , Key key, Value val) {
        //如果没有这个键就新增一个
        if(x == null) {
            return x = new Node(key , val, 1);
        }
        //沿途二分找键，遇到的根节点键大，则在其左子树递归查找，键小，在右子树递归查找，
        //直到找到相等或者发现根节点为空为止
        int cmp = x.key.compareTo(key);
        if(cmp > 0) {
            x.left = put(x.left , key, val);
        }
        else if(cmp < 0) {
            x.right = put(x.right , key , val);
        }
        else {
            x.val = val;
        }
        //沿途回溯更新结点的size  自底向上
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }
    
    //返回键的最小值
    public Key minK() {
        return minK(root).key;
    }
    private Node minK(Node x) {
        if(x.left != null) {
            return minK(x.left);
        }
        return x;
    }
    //返回键的最小值
    public Key maxK() {
        return maxK(root).key;
    }
    private Node maxK(Node x) {
        if(x.right != null) {
            return maxK(x.right);
        }
        return x;
    }
    //返回小于等于key的最大值
    public Key floor(Key key) {
        Node x = floor(root , key);
        if(x != null) return x.key;
        return null;
    }

    //返回小于等于key的最大值所在结点
    private Node floor(Node x , Key key) {
        if(x == null) return null;
        //比较当前根节点的键值是否大于key
        int cmp = x.key.compareTo(key);
        if(cmp == 0) return x;
        //如果根结点的键值小于key，那么小于等于key的键值有可能在根节点的右子树中，如果没有则就是根节点
        else if(cmp < 0) {
            Node t =  floor(x.right , key);
            if(t == null) return x;
            else {
                return t;
            }
        }
        //如果根节点的键值大于key，则小于等于key的键值必定在根节点的左子树中
        else {
            return floor(x.left , key);
        }
    }
    
    public Key ceiling(Key key) {
        Node x = ceiling(root , key);
        if(x != null) return x.key;
        return null;
    }

    //返回大于等于key的最小值所在结点
    private Node ceiling(Node x , Key key) {
        if(x == null) return null;
        //比较当前根节点的键值是否大于key
        int cmp = x.key.compareTo(key);
        if(cmp == 0) return x;
        //如果根节点的键值大于key，则大于等于key的键值有可能在根节点的左子树中，如果没有就是根节点
        else if(cmp > 0) {
            Node t =  ceiling(x.left , key);
            if(t == null) return x;
            else {
                return t;
            }
        }
        //如果根结点的键值小于key，那么大于等于key的键值一定在根节点的右子树中
        else {
            return ceiling(x.right , key);
        }
    }

    //查找排名为K的键(树中恰好有K个小于他的键)
    public Key select(int k) {
        Node x = select(root , k);
        if(x == null) return null;
        return x.key;
    }
    private Node select(Node x , int k) {
        if(x == null) return null;
        int t = size(x.left);
        if( t > k) {
            return select(x.left , k);
        }
        else if(t == k) {
            return x;
        }
        else {
            return select(x.right , k - t - 1);
        }
    }

    //给定一个键求其排名(即求有多少个键小于它)
    public int rank(Key key) {
        return rank(root , key);
    }
    private int rank(Node x , Key key) {
        if(x == null) return 0;
        int cmp = x.key.compareTo(key);
        if(cmp == 0) {
            return size(x.left);
        }
        else if(cmp > 0) {
            return rank(x.left , key);
        }
        else {
            return size(x.left) + rank(x.right , key) + 1; 
        }
    }
    
    //删除一棵树的最小结点
    public void deleteMin() {
        root = deleteMin(root);
    }

    private Node deleteMin(Node x) {
        // TODO Auto-generated method stub
        if(x.left != null) {
            x.left = deleteMin(x.left);
            x.N = size(x.left) + size(x.right) + 1;
            return x;
        }
        return x.right;
    }
    
    public void delete(Key key) {
        root = delete(root , key);
    }
    public Node delete(Node x, Key key) {
        if(x ==  null) return null;
        int cmp = x.key.compareTo(key);
        if(cmp > 0) {
            x.left = delete(x.left , key);
        }
        else if(cmp < 0) {
            x.right = delete(x.right ,  key);
        }
        else {
            //找到要删除的结点了
            if(x.left == null) return x.right;
            if(x.right == null) return x.left;
            
            Node t = x;
            x = minK(t.right);
            x.right = deleteMin(t.right);
            x.left = t.left;
        }
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }
    
    //返回整棵树的迭代对象
    public Iterable<Key> keys(){
        return keys(minK() , maxK());
    }
    
    //返回范围[lo , hi]内所有key的迭代对象
    public Iterable<Key> keys(Key lo, Key hi) {
        // TODO Auto-generated method stub
        Queue<Key> queue = new LinkedList<Key>();
        keys(root , queue, lo, hi);
        return queue;
    }
    //把[lo , hi]范围内的所有元素加入指定迭代对象中
    private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
        // TODO Auto-generated method stub
        if(x == null) return ;
        int cmplo = x.key.compareTo(lo);
        int cmphi = x.key.compareTo(hi);
        //如果根节点大于lo说明根节点的左子树可能还有元素在此范围内
        if(cmplo > 0) {
            keys(x.left, queue, lo, hi);
        }
        //如果根节点小于hi说明根节点的右子树可能还有元素在此范围内
        if(cmphi < 0) {
            keys(x.right, queue, lo, hi);
        }
        //遇到一个结点在此范围内就将其加入集合
        if(cmplo >= 0 && cmphi <= 0) {
            queue.add(x.key);
        }
    }
    //前序遍历 左中右遍历  顺序遍历
    public void show(Node x) {
        if(x != null) {
            show(x.left);
            System.out.println(x.key.toString() + " : " + x.val.toString());
            show(x.right);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BST bst = new BST<Integer , Integer>();
        Random r = new Random();
        for(int i=0; i<10; i++) {
            Integer key = new Integer(r.nextInt(1000));
            Integer value = new Integer(r.nextInt(1000));
            System.out.println("key = " + key + " value = " + value);
            bst.put(key, value);
        }
        System.out.println("put 操作完毕");
        // 186 244 336 481 507 514 663 729 743 759 761 891
        bst.show(bst.root);
        
        System.out.println("show 操作完毕");
        
        //bst.put(759, 19999);
        //bst.put(761, 19999);
        System.out.println(bst.get(9999));
        System.out.println(bst.get(8888));
        
        System.out.println(bst.floor(760));
        System.out.println(bst.ceiling(760));
        System.out.println(bst.maxK());
        System.out.println(bst.select(0));
        System.out.println(bst.rank(0));
        bst.deleteMin();
        bst.put(1000, 9999);
        bst.show(bst.root);
        bst.delete(1000);
        bst.show(bst.root);
        System.out.println("################");
        Iterable<Integer> it = bst.keys(200,600);
        for(Integer i : it) {
            System.out.print(i.toString() + " ");
        }
    }
    
    

}