【数据结构】优先级队列(堆)

💐1. 优先级队列

1.1 概念

队列是一种先进先出的数据结构，但是呢，有时候，数据之间也会有优先级，就比如说，我们想要拿到一个集合中的前k大的数据，或者是在平时，我们在打游戏时，这时候来电话了，但是，游戏也不能让他退出呀，这时候就会忽略掉电话，由此可见，游戏的优先级要比电话的优先级更高；

💐2.堆的概念及存储方式

优先级队列是由堆实现的， 而堆实际实际上是在完全二叉树的基础上进行了调整，而此时也就用到了 二叉树的顺序存储方式 这句话是什么意思呢？请看下图：

2.1 什么是堆

这里不做详细的介绍，只需知道，所有引用类型所创建的对象都保存在堆上，包括数组；而这里的堆是将所有的元素，按照完全二叉树的顺序存储方式存储到了一维数组中；

2.2 为什么要用完全二叉树描述堆呢？

2.3 为什么说堆是在完全二叉树的基础上进行的调整？

​ 堆又分为了大根堆和小根堆：

​ 从上图就可以发现两个性质：

​ 1.大根堆中，所有的父节点都比子节点大

​ 2.小根堆中，所有的父节点都比子节点小

2.4 使用数组还原完全二叉树

​ 在二叉树文章中，提到过这样一条性质：如果每一个节点都有一个编号 i 的话，那么：

1.当 i > 0 时，i 节点的父亲节点为: (i - 1) / 2;

2.如果 2i +1 < 节点的总数时，则下标为 i 节点的左孩子节点的下标为 2i + 1

3.如果 2i + 2 < 节点的总数时， 则下标为 i 的节点的左孩子节点的下标为 2i + 1

因为是在数组中进行存储的，所以完全二叉树中每一个节点的编号都是数组中每一个元素的下标；所以这样就可以使用数组来还原完全二叉树，然后再对完全二叉树进行调整；

在上一篇文章中，对于 优先级队列的概念及存储方式进行了一个详细的讲解，那么，本篇文章主要是针对优先级队列底层实现大致是什么样子的，亲手写一下代码结合图为大家讲解：

💐3. 堆的常用操作-模拟实现

3.1 堆的创建

我们知道，在上一篇文章中讲过，所有的元素都是在数组中存储的，那么，如何利用数组来实现 大根堆 和 小根堆的创建呢？就要考虑下面这个问题：

如果出现子节点比父节点大或者小该怎么办呢，怎么去调整呢？

3.1.1 堆的向下调整(大根堆为例)

可以看出，最后一棵子树的子节点比父节点大，我们所用的方法就是：

代码实现：

public class MyPriorityQueue {
    //底层数组
    private int[] element;
    //数组中的元素
    private int usedSize;
    //初始默认容量
    private static final int default_capacity = 9;
    public MyPriorityQueue(int[] arr) {
        this.element = new int[default_capacity];
        //传入一个数组，对element进行构造
        for(int i = 0; i<arr.length; i++) {
            element[i] = arr[i];
            usedSize++;
        }
    }

    //建一个大根堆
    public void buildHeap() {
        //parent 求出最后一棵子树的父亲节点
        for(int parent = (usedSize-2)/2; parent >= 0; parent--) {
            /*
            为什么减2而不是减1呢？
            因为，如果是最后一个节点的下标值，就是减一，但是，数组的长度值比下标大1，所以减2
             */
            //向下调整
            shiftDown(parent, usedSize);
        }
    }
    private void shiftDown(int parent, int len) {
        //求左孩子节点
        int child = (2*parent)+1;

        //判断是否有右孩子节点并且判断左孩子节点是否大于右孩子节点
        if(child+1 < len && element[child] < element[child+1]){
            //得到最大的孩子节点
            child++;
        }
        //判断孩子节点是否比父亲节点大
        if(element[child] > element[parent]) {
            //进行交换
            swap(parent, child);
        }
    }
    private void swap(int parent, int child) {
        int tmp = element[parent];
        element[parent] = element[child];
        element[child] = tmp;
    }
    
        public static void main(String[] args) {
        //测试用例
        int[] ele = {50, 45, 40, 20, 25, 35, 30, 10, 60};
        MyPriorityQueue myPriorityQueue = new MyPriorityQueue(ele);
        myPriorityQueue.buildHeap();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

但是，上述代码存在一个致命的问题：

代码优化：

    private void shiftDown(int parent, int len) {
        //求左孩子节点
        int child = (2*parent)+1;
        while(child < len) {
            //判断是否有右孩子节点并且判断左孩子节点是否大于右孩子节点
            if(child+1 < len && element[child] < element[child+1]){
                //得到最大的孩子节点
                child++;
            }
            //判断孩子节点是否比父亲节点大
            if(element[child] > element[parent]) {
                //进行交换
                swap(parent, child);
                //保证交换后，该树的子树仍然是大根堆
                parent = child;
                child = (2*parent)+1;
            }else {
                //表示以该节点为根的树已经是大根堆了
                break;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.1.2 建堆的时间复杂度

在学会了建堆以后，接下来就聊一聊建堆所用的复杂度吧！先说结论，最坏的情况是O(n),下面我来推到以下：

在推导之前先说明一下：因为堆是完全二叉树，而满二叉树也是完全二叉树，多几个节点也无所谓，时间复杂度本来就是一个近似值，所以为了容易理解，这里会用满二叉树进行推导

3.2 堆的插入和删除

3.2.1 堆的插入

堆的插入分为两个步骤：

1.将要添加的元素放在底层数组的最后一个位置；注意是否要扩容问题

2.向上调整该元素

下面讲解一下什么是向上调整

直接拿要添加的元素与根节点相比较，因为，本身已经是大根堆了，直接与根节点比较，符合条件就交换，不需要再与其他的节点比较

代码实现：

    //插入方法
    public void offer(int val) {
        //判断是否需要扩容
        if(is_full()) {
            this.element = Arrays.copyOf(element, element.length+1);
        }
        //向上调整
        this.element[usedSize] = val;
        shiftUp();
        usedSize++;
    }

    //向上调整
    private void shiftUp() {
       int parent = (usedSize-1)/2;
       int child = usedSize;
       while(child > 0) {
           if(element[parent] < element[child]) {
               swap(parent, child);
           }
           child = parent;
           parent = (child-1)/2;
       }
    }
    private boolean is_full() {
        return usedSize == element.length;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.2.2 堆的删除

1.将第一个元素和最后一个元素进行交换

2.节点实际上并没有被删除，而是节点的个数useSize减1

3.最后向上调整

代码实现

    //删除
    public void poll() {
        //排除空堆情况
        if(usedSize == 0) {
            return;
        }
        //交换第一个和最后一个元素
        swap(0,usedSize-1);
        //节点个数减1，不会对最后一个元素进行判断
        usedSize--;
        for(int parent = (usedSize-1)/2; parent >= 0; parent--) {
            //向下调整
            shiftDown(parent, usedSize);
        }
    }

	private void shiftDown(int parent, int len) {
        //求左孩子节点
        int child = (2*parent)+1;
        while(child < len) {
            //判断是否有右孩子节点并且判断左孩子节点是否大于右孩子节点
            if(child+1 < len && element[child] < element[child+1]){
                //得到最大的孩子节点
                child++;
            }
            //判断孩子节点是否比父亲节点大
            if(element[child] > element[parent]) {
                //进行交换
                swap(parent, child);
                //保证交换后，该树的子树仍然是大根堆
                parent = child;
                child = (2*parent)+1;
            }else {
                //表示以该节点为根的树已经是大根堆了
                break;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

💐4. PriorityQueue常用接口及特性

Java的集合框架中提供了PriorityQueue 和PriorityBlockingQueue两种类型的优先级队列 ，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的，本篇文章主要介绍PriorityQueue

PriorityQueue的构造

代码实现

   public static void main(String[] args) {
        //创建一个空的优先队列，底层默认容量是11
        PriorityQueue<Integer> priorityQueue1 = new PriorityQueue<>();

        //创建一个空的优先级队列，指定容量为100
        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(100);

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //使用其他集合构造优先级队列
        PriorityQueue<Integer> priorityQueue3 = new PriorityQueue<>(list);

        //默认是小根堆，想要变成大根堆需要传入比较器
        PriorityQueue<Integer> priorityQueue4 = new PriorityQueue<>(new com());
        priorityQueue4.offer(1);
        priorityQueue4.offer(2);
        priorityQueue4.offer(3);
    }
    //定义一个比较器
class com implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

PriorityQueue使用时需要注意：

1.使用时必须导入PriorityQueue所在的包，即：

import java.until.PriorityQueue;
1

2. PriorityQueue中放置的元素必须要能够比较大小，不能插入不能比较大小的队象，否则会抛出ClassCastException异常
3. 不能插入 null对象， 否则会抛出NullPointerException
4. 没有容量限制，可以插入多个元素，其内部可以自动扩容
5. 插入和删除元素的时间复杂度为O(log2N)
6. PriorityQueue底层使用了堆数据结构
7. PriorityQueue默认情况下是小根堆

Java中提供的方法：

优先级队列的扩容源码分析

💐5. PriorityQueue的比较方式

PriorityQueue底层使用堆结构，所以，内部的元素必须能够比较大小，PriorityQueue采用了：Comparble 和 Comjparator两种方式。

1. Comparble默认的内部比较方式，如果用户插入自定义类型对象是，该类对象必须要实现Comparble接口，并且要重写compareTo方法

2. 也可以使用比较器，用户自己实现一个比较器类且实现Comaparator接口，并且让该类重写compare方法，指定根据对象的什么内容进行比较，然后再实例化PriorityQueue对象时，把比较器传进去；

源码讲解：

	//内部定义的比较器对象
    private final Comparator<? super E> comparator;

	//如果用户没有提供比较器，则使用内部的比较方式，将comparator置为null
	public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

	//如果用户提供了比较器，则采用提供的比较器进行比较
	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;
    }

	//在添加对象时进行向上调整
	//如果没有提供比较器，则采用内部比较方式，即Comparable
	//如果提供了比较器，则采用比较器进行比较
	 private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

	//采用comparable进行比较
    private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
    }
	//采用comparator进行比较
    private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

💐6. 例子：使用优先级队列解决TOP-k问题

TOP-K 问题：求数据集合中前K个最大的元素或者最小的元素，一般数据量都比较大；

[面试题 17.14. 最小K个数 - 力扣（LeetCode）]()

class Solution {
    public int[] smallestK(int[] arr, int k) {
        //创建一个优先级队列
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        //将所有元素加入到队列中
        for(int i = 0; i<arr.length; i++) {
            heap.add(arr[i]);
        }
        //创建一个数组用来存储前k个元素
        int[] ans = new int[k];
        //将堆中的前k个元素保存在数组中
        for(int i = 0; i<k; i++) {
            ans[i] = heap.poll();
        }
        //返回数组
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

但是，上面这个代码只能针对于数据量较小时才行，如果数据量太大就会造成时间复杂度过高，比如，有一亿个数据，如果使用以上代码的话，会先将一亿个数据都保存在堆中，然后进行比较，这就得不偿失了；那么就要对代码进行一个优化：

1.用集合中的前k个元素建堆；

• 前k大个元素建小堆
• 前k小个元素建大堆

2.用剩余的n(元素的个数) - k个元素与堆中的元素进行比较；最后堆中剩余的元素就是前k个最大或最小的元素

代码实现：

    public int[] smallestK(int[] arr, int k) {
        //求前k个最小元素，所以要建大根堆，因为PriorityQueue默认的是小根堆，所以要传入比较器
        PriorityQueue<Integer> heap = new PriorityQueue<>(new Com());
        //将前k个元素加入到堆中
        for(int i = 0; i<k; i++){
            heap.add(arr[i]);
        }
        if(heap.isEmpty()) {
            return new int[]{};
        }
        //用剩余的元素与堆顶元素比较
        for(int i = k; i<arr.length; i++) {
            int x = heap.peek();
            //这里的条件语句求的是前k个最小元素
            if(arr[i] < x){
                heap.poll();
                heap.offer(arr[i]);
            }
        }

        int[] ans = new int[k];
        for(int i = 0; i<k; i++){
            ans[i] = heap.poll();
        }
        return ans;
    }
}
//自定义一个比较器
class Com implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34