目录

堆的介绍

建堆

向下调整算法

 向下调整算法时间复杂度分析

建堆时间复杂度分析

 堆的插入和删除

PriorityQueue底层原码分析

优先级队列应用之topK问题

---

在有些情况下，我们不一定要让数据立马全部有序，比如当我们在打游戏时，突然有人打电话，游戏界面就会立马卡住不动，我们可以选择立马接电话或者立马挂电话。这就是我们应用程序在设计时，都需要有个优先级，最重要的一定会排在前面，然后在完成次大.......，这就引出了我们今天要讲的一种数据结构优先级队列，在Java jdk1.8中也给我们提供了接口PriorityQueue.

堆的介绍

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为 小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的特点

• 堆是按照完全二叉树来顺序存储的，将其保存在数组中(一定是一颗完全二叉树)
• 大根堆：根节点都大于两个子节点并且每个子树也要按照这个规则，每一棵子树也是大根堆
• 小根堆：根节点都小于两个子节点并且每个子树也要按照这个规则，每一棵子树也是小根堆

• 为什么一定要按照一颗完全二叉树的顺序呢？？？非完全二叉树不可以么？

原因是：如果要按照一颗非完全二叉树的顺序来存储，那么存储到数组中的节点必定要有null,节点，这些空节点在数组中某个位置就相当于为空，就会大量浪费数组的空间，空间利用率大大降低。

• 那么我们可以不存储空节点么？？

答案是不可以的因为，我们既然要将这颗二叉树存起来，我们肯定也要将它还原回来，如果不存储的话就无法还原一颗二叉树。

那么如何来建一个大根堆或者小根堆呢？？？

建堆

我们这里以建立大根堆为例

建立一个大根堆，最重要的就是向下调整。

向下调整算法：从最后一个父节点开始进行调整，如果父节点小于任意一个孩子，就进行交换，最终父亲节点比两个孩子大，接着调整上一个父节点，如此往复，最终就是一个大根堆。

• 既然我们要从最后一个父节点开始向下调整，那怎么找到最后一个父节点以及孩子呢？？

最后一个孩子肯定就是数组最后一个元素，而对于一颗完全二叉树来说，给我们孩子节点，我们利用公式 (i -1)/2就是我们的父节点。

• 如果要向下调整怎么才算是调整结束呢？

当我们调整完一颗子树，开始向下调整，肯定要进行父节点和子节点进行更新，而当我们的子节点超出我们数组有效范围内就证明一颗树向下调整结束。

向下调整算法

 向下调整

• 从最后一个父节点开始进行向下调整，每一次找左右孩子中节点最大的与父节点进行比较，如果比父节点大就进行交换，否则，证明这颗子树就是一个大根堆不需要向下调整。
• 每一次调整完一颗子树之后就进行父节点和子节点更新 父节点->子节点(parent = child),子节点到新的子节点(child = 2*parent+1)<---左孩子结点，一直调整到孩子节点不在数组有效范围内，证明向下调整完毕---->建立大根堆完成。

//向下调整算法
    public void shiftDown(int[] array,int parent,int len){
        int child = 2*parent+1;
        while(child<len){
            //找左右孩子节点最大的值
            if(child+1<len&&array[child]<array[child+1]){
                child++;
            }
            //此时child就是左右孩子节点最大的
            //与父亲节点进行比较
            if(array[parent]<array[child]){
                swap(array,parent,child);
            }else {
               break;//并不需要进行交换这棵树已经是大根堆
            }
            parent = child;
            child = 2*parent+1;
        }
    }

 向下调整算法时间复杂度分析

最坏情况下，一路从根节点比较到叶子结点，所以比较次数就是完全二叉树的高度，时间复杂度为O(log2N)

• 建立大根堆

public class Heap {
 
    public int[] elem;//将堆中存放到数组中
    public int usedSize;//数组的有效个数
 
    public Heap(){
        this.elem = new int[10];
        this.usedSize =0;
    }
 
    //交换两个元素
    public void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
 
    //向下调整算法
    public void shiftDown(int[] array,int parent,int len){
        int child = 2*parent+1;
        while(child<len){
            //找左右孩子节点最大的值
            if(child+1<len&&array[child]<array[child+1]){
                child++;
            }
            //此时child就是左右孩子节点最大的
            //与父亲节点进行比较
            if(array[parent]<array[child]){
                swap(array,parent,child);
            }else {
               break;//并不需要进行交换这棵树已经是大根堆
            }
            parent = child;
            child = 2*parent+1;
        }
    }
 
    //建堆
    public void createHeap(int[] array){
        //将array数组元素都保存到elem数组中去
        for(int i =0;i<array.length;++i){
            this.elem[i] = array[i];
            this.usedSize++;
        }
        //通过找到最后一个父节点来进行向下调整
        for(int p = (this.usedSize-1-1)/2;p>=0;p--){
            shiftDown(this.elem,p,this.usedSize);
        }
    }
}

建堆时间复杂度分析

 堆的插入和删除

• 堆的插入

•  插入元素插入到数组最后，然后插入元素与父节点进行比较，如果比父节点大那就进行交换，继续维持一个大根堆。
• 一直调整到parent小于0证明这个元素插入完毕，维持成大根堆。
• 这里如果插入元素满了-->可以选择增容

//向上调整算法
    public void shiftUp(int child){
        int parent = (child-1)/2;//根据孩子节点推算出父节点
        while(parent>=0){//parent小于0则调整结束
            if(this.elem[child]>this.elem[parent]){
                swap(this.elem,parent,child);
            }else {
                break;
            }
            //更新父节点和子节点
            child = parent;
            parent = (child-1)/2;
        }
    }
 
    //增容
    public void grow(){
        this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
    }
 
    //堆的插入
    public void offer(int key){
        if(this.elem.length==this.usedSize){
            grow();
        }
        //先将key插入到数组最后一个位置
        //然后再将key向上调整到合适位置使整个堆依然为大根堆
        this.elem[this.usedSize] = key;
        shiftUp(this.usedSize);
        this.usedSize++;
    }

• 堆的删除

• 堆的删除元素是指删除堆顶元素，第一步：将堆顶元素与数组最后一个进行交换，然后将堆顶元素向下调整为大根堆，维持大根堆，第二步将数组有效个数-1，将数组最后一个位置元素删除
• 当堆为空时，不能删除

 public boolean isEmpty(){//判断堆是否为空
        return this.usedSize==this.elem.length;
    }
 
    public void poll(){
        if(isEmpty()){
            System.out.println("该堆为空不能删除");
            return ;
        }
        swap(this.elem,0,this.usedSize-1);//将堆顶元素与最后一个元素交换
        shiftDown(this.elem,0,this.usedSize-1);//将堆顶元素向下调整
        this.usedSize--;//有效个数--
    }

• 堆的插入和删除时间复杂度最坏都要调整一棵树为：O(log2N)

PriorityQueue底层原码分析

1. 使用时必须导入PriorityQueue所在的包，即：import java.util.PriorityQueue;
2. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出
ClassCastException异常
3. 不能插入null对象，否则会抛出NullPointerException
4. 没有容量限制，可以插入任意多个元素，其内部可以自动扩容
5. 插入和删除元素的时间复杂度为O(log2N)
6. PriorityQueue底层使用了堆数据结构, (注意：此处大家可以不用管什么是堆，后文中有介绍)
7. PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素

//数组初始化默认容量为11
private static final int DEFAULT_INITIAL_CAPACITY = 11;
//底层使用一个Object类型的数组
transient Object[] queue;
//如果没有传比较器，或者按照默认的排序，则比较器为null
private final Comparator<? super E> comparator;
//创建一个默认容量为11的priorityQueue,该队列按照自然排序进行排序(也就是小堆)
public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
}
//创建一个具有指定容量的PriorityQueue,该队列按照自然排序进行排序(也就是小堆)
//这里注意初始容量不能小于1，如果小于1就会抛IllegalArgumentException异常
 public PriorityQueue(int initialCapacity) {
        this(initialCapacity, null);
}
//创建一个默认容量为11的priorityQueue，该队列按照比较器进行排序
public PriorityQueue(Comparator<? super E> comparator) {
        this(DEFAULT_INITIAL_CAPACITY, comparator);
}
//创建一个具有指定容量的PriorityQueue,该队列按照比较器进行排序
public PriorityQueue(int initialCapacity,
                         Comparator<? super E> comparator) {
        // Note: This restriction of at least one is not actually needed,
        // but continues for 1.5 compatibility
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
}
 
//插入元素offer
//这里还要注意如果比较的是自定义类型，不是内置类型，就必须可比较否则会抛异常
//ClassCastException
public boolean offer(E e) {
    if (e == null)//如果插入元素为null,则就会抛空指针异常
        throw new NullPointerException();
    modCount++;
    int i = size;//获取当前优先级队列长度
    if (i >= queue.length)//如果当前优先级队列大于数组长度就要进行扩容
        grow(i + 1);
    size = i + 1;//插入一个元素，有效个数+1
    if (i == 0)//刚开始插入元素，插入0下标
        queue[0] = e;
    else//如果不是第一次插入元素，就向上调整到合适位置
        siftUp(i, e);
    return true;
}
//向上调整
private void siftUp(int k, E x) {
    if (comparator != null)//一个是按照比较器来排序
        siftUpUsingComparator(k, x);
    else//按照自然排序(默认是小堆)
        siftUpComparable(k, x);
}
//siftUpComparable
private void siftUpComparable(int k, E x) {
    //将x强转为Comparable类型能够比较
    Comparable<? super E> key = (Comparable<? super E>) x;
    while (k > 0) {
        //根据k(孩子节点)推算出父亲节点 (i-1)/2
        int parent = (k - 1) >>> 1;
        Object e = queue[parent];//先将父亲节点保存起来然后与传入的元素进行比较
        if (key.compareTo((E) e) >= 0)//(默认是小堆)
            break;//如果传入的元素要大于父亲元素就跳出循环,因为这里是在自然排序
        queue[k] = e;//否则的话比父亲节点要小，就与父亲节点进行交换
        k = parent;
    }
    queue[k] = key;//这里如果key比parent小就交换，否则放回原来的位置
}
//返回堆顶元素
public E peek() {
     return (size == 0) ? null : (E) queue[0];
}
 
//弹出堆顶元素
public E poll() {
    if (size == 0)//如果有效个数为0不能删除
        return null;
    int s = --size;//保存删除元素之后，数组元素最后的下标
    modCount++;
    E result = (E) queue[0];//保存0下标(要删除的元素)的值
    E x = (E) queue[s];//保存删除元素之后，数组最后一个元素
    queue[s] = null;
    if (s != 0)//如果有效个数不为0的话就进行向下调整
        siftDown(0, x);
    return result;
}
private void siftDownComparable(int k, E x) {
    Comparable<? super E> key = (Comparable<? super E>)x;
    int half = size >>> 1;        // loop while a non-leaf
    while (k < half) {
        int child = (k << 1) + 1; // assume left child is least
        Object c = queue[child];
        int right = child + 1;
        if (right < size &&
            ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
            c = queue[child = right];
        if (key.compareTo((E) c) <= 0)
            break;
        queue[k] = c;
        k = child;
    }
    queue[k] = key;
}
//扩容
private void grow(int minCapacity) {
    int oldCapacity = queue.length;
    // Double size if small; else grow by 50%
    //如果容量小于64时，是按照oldCapacity的2倍方式扩容的
    //如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的
    //如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容
    int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                     (oldCapacity + 2) :
                                     (oldCapacity >> 1));
    // overflow-conscious code
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    queue = Arrays.copyOf(queue, newCapacity);
}

优先级队列应用之topK问题

什么是topk问题呢？？？

比如中国大学的排名，前3名，清华北大浙大。这就是选取众多高校中最厉害的三所高校，对于我们数据也一样，比如我们要在1~10数字之间选择前3大的数据，那肯定就是10,9,8三个元素。那我们知道今天学的优先级队列就是根据数据的优先级而排列的，那我们怎么利用优先级队列这种数据结构来解决topK问题呢？？？

我们第一个想法那肯定就是建立大堆啊？建立大堆之后我们将堆顶元素弹出3次，这三个元素就是我们的在这个10个数字中前3大的元素。

• 代码实现

public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        for(int num:array){
            pq.offer(num);
        }
        for(int i =0;i<3;++i){
            System.out.println(pq.poll());
        }
    }

这个时间复杂度为：因为调整的时间复杂度为log2N,我们要选取前n个大的那就是N*log2N

我们能不能在进行优化呢？？

我们可以按照：

• 如果选前k个小的我们就建大堆
• 如果选前k个大的我们就建小堆

这里选前k个大的建小堆为例。

• 首先先将k个元素建立成小堆
• 然后从k+1位置元素往后遍历。
• 如果遍历元素比堆顶元素小，他不可能是前k个最大的，因为我们建立的是小堆，堆顶元素是最小的，如果比堆顶元素还小，那就说明不是前k个最大的。
• 相反如果比堆顶元素大，那就说明这个元素可能是前k个最大的，所以我们将堆顶元素删除，然后将这个元素插入，继续维持小根堆状态。
• 直到遍历完所有元素，堆中元素就是前k个最大的。

 

class Solution {
 //取前k个最小的元素
    public int[] smallestK(int[] array, int k) {
        if(k==0){
            return new int[k];
        }
        //建造一个大堆
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k,new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        //我们要先建造一个k大小的堆
        int i =0;
        for(i=0;i<k;++i){
            maxHeap.offer(array[i]);
        }
        //此时i指向的元素就是第四个元素
        //因为我们要找前k个最小的元素所以如果碰见这个元素大于堆顶元素，
        //那么这个元素一定不是前k个最小的元素如果这个元素小于堆顶元素，那么就将对顶元素弹出然后将这个元素加入堆中
        for(;i<array.length;++i){
            int temp = maxHeap.peek();
            if(array[i]<temp){
                maxHeap.poll();
                maxHeap.offer(array[i]);
            }
        }
        int[] ret = new int[k];
        for(int j =0;j<k;++j){
            ret[j]=maxHeap.poll();
        }
         return ret;
    }
}

• 思考

其实我们还可以发现前三大的是这三个元素，而第三大的就是我们堆顶元素