Java 优先级队列与堆

目录

优先级队列的概念

堆的概念

 堆的存储方式

堆的创建

堆的向下调整法

堆的创建

建堆的时间复杂度

堆的插入与删除

堆的插入

堆的删除

PriorityQueue的特性

PriorityQueue常用接口介绍

优先级队列的使用

堆排序

---

优先级队列的概念

队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，在这种情况下，使用队列显然不合适，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。

这种数据结构就是优先级队列(Priority Queue)。

堆的概念

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

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

 堆中某个节点的值总是不大于或不小于其父节点的值；

堆总是一棵完全二叉树。

 堆的存储方式

堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储

对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。

将元素存储到数组中后，假设i为节点在数组中的下标，则有：

如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2

如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子

如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子

import java.util.Arrays;
public class TestHeap {
    public int[] elem;
    public int usedSize;

    public TestHeap() {
        this.elem = new int[10];
    }
}

堆的创建

堆的向下调整法

向下过程(以小堆为例)：

1. 让parent标记需要调整的节点，child标记parent的左孩子(注意：parent如果有孩子一定先是有左孩子)

2. 如果parent的左孩子存在，即:child < size， 进行以下操作，直到parent的左孩子不存在

        (A)parent右孩子是否存在，存在找到左右孩子中最小的孩子，让child进行标记

        (B)将parent与较小的孩子child比较，如果：

                (a)parent小于较小的孩子child，调整结束

                (b)否则：交换parent与较小的孩子child，交换完成之后，parent中大的元素向下移

                    动，可能导致子树不满足对的性质，因此需要继续向下调整，即parent = child；

                    child = parent*2+1; 然后继续2。

public void shiftDown(int parent,int len) {
    int child = (2 * parent)+1;
    //说明这棵树没有调整完
    while (child < len) {
        //如果有右孩子 你才去判断
        if(child+1 < len && elem[child] < elem[child+1]) {
            child++;
        }
        //child下标 一定是左右孩子最大值的下标
        if(elem[child] > elem[parent]) {
            int tmp = elem[parent];
            elem[parent] = elem[child];
            elem[child] = tmp;
            parent = child;
            child = 2*parent+1;
        }else {
            break;
        }
    }
}

最坏的情况即图示的情况，从根一路比较到叶子，比较的次数为完全二叉树的高度，即时间复杂度为O(logN)

同理，堆的向上调整法

public void shiftUp(int child) {
    int parent = (child-1) / 2;
    while (parent >= 0) {
        if(elem[child] > elem[parent]) {
            int tmp = elem[parent];
            elem[parent] = elem[child];
            elem[child] = tmp;
            child = parent;
            parent = (child-1)/2;
        }else {
            break;
        }
    }
}

堆的创建

public void createHeap(int[] array) {
    //this.elem = Arrays.copyOf(array,array.length); 不算
    for (int i = 0; i < array.length; i++) {
        elem[i] = array[i];
        this.usedSize++;
    }

    for (int i = (usedSize-1-1)/2; i >= 0 ; i--) {
        shiftDown(i,usedSize);
    }

}

建堆的时间复杂度

 因此，建堆的时间复杂度为O(N)

堆的插入与删除

堆的插入

堆的插入总共需要两个步骤：

1. 先将元素放入到底层空间中(注意：空间不够时需要扩容)

2. 将最后新插入的节点向上调整，直到满足堆的性质

public void push(int val) {
    if(isFull()) {
        this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
    }
    this.elem[this.usedSize] = val;
    this.usedSize++;
    shiftUp(this.usedSize-1);
}

public boolean isFull() {
    return this.usedSize == this.elem.length;
}

堆的删除

堆的删除一定删除的是堆顶元素。

1. 将堆顶元素对堆中最后一个元素交换

2. 将堆中有效数据个数减少一个

3. 对堆顶元素进行向下调整

public int pop() {
    if(isEmpty()) {
        throw new HeapEmptyException("堆为空！");
    }
    int tmp = elem[0];
    elem[0] = elem[this.usedSize-1];
    elem[this.usedSize-1] = tmp;
    this.usedSize--;
    shiftDown(0,this.usedSize);
    return tmp;
}

public boolean isEmpty() {
    return this.usedSize == 0;
}

PriorityQueue的特性

 Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的

 

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

import java.util.PriorityQueue;

2. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常

3. 不能插入null对象，否则会抛出NullPointerException

4. 没有容量限制，可以插入任意多个元素，其内部可以自动扩容

5. 插入和删除元素的时间复杂度为 O(logN)

6. PriorityQueue底层使用了堆数据结构, (注意：此处大家可以不用管什么是堆，后文中有介绍)

7. PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素

PriorityQueue常用接口介绍

优先级队列的使用

public static void main(String[] args) {
    //默认容量是11    小根堆
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
    priorityQueue.offer(10);
    priorityQueue.offer(8);
    priorityQueue.offer(30);
    priorityQueue.offer(5);

    System.out.println(priorityQueue.poll());//5
    System.out.println(priorityQueue.peek());//8
}

默认情况下，PriorityQueue队列是小堆，如果需要大堆需要用户提供比较器

public static void main(String[] args) {
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>(new Comparator<Integer>() {
        public int compare(Integer a, Integer b) {
            return b - a;
        }
    });
    
    /*
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>((a,b)->b-a);
    */
    
    priorityQueue.offer(10);
    priorityQueue.offer(8);
    priorityQueue.offer(30);
    priorityQueue.offer(5);

    System.out.println(priorityQueue.poll());//30
    System.out.println(priorityQueue.peek());//10
}

堆排序

public void heapSort() {
    int end = usedSize-1;
    while (end > 0) {
        int tmp = elem[end];
        elem[end] = elem[0];
        elem[0] = tmp;
        shiftDown(0,end);
        end--;
    }
}

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

1. 建堆升序：建大堆

           降序：建小堆

2. 利用堆删除思想来进行排序