优先级队列

一、序

队列是一种先进先出（FIFO）的结构，而优先级队列，我们是按照元素在队列中的优先级来操作的。对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。它应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列。

优先级队列的实现方式有很多种，最常见的是使用堆来构建。

二、堆（heap）

1.概念

1. 堆在逻辑上是一棵完全二叉树
2. 堆物理上是保存在数组中的
3. 任意结点的值都大于其子树中结点的值叫大堆，反之，叫做小堆
4. 堆的基本作用是，快速找集合中的最值（Top K 问题）

2.基本操作

2.1向下调整

向下调整有个前提：它的左右子树必须已经是堆了，才能调整

以大堆为例子：

我们要建立一个大堆，就得多次循环，进行向下调整。向下调整首先得到左右孩子中最大的那个（记为 child ），然后与当前结点（记为parent）进行比较，如果parent比较大，就不用调整了，否则，进行交换。重复上述步骤直至到达叶子节点为止。

2.2向上调整

以大堆为例子：

如果我们把堆顶的元素给删除了，那么就需要往此处插入一个元素，从叶子结点出发，然后向上调整，使堆仍然保持结构。向上调整，已知叶子结点位置child，比较的是当前位置child 和其 parent结点的大下，如果parent 比较大，就结束调整，否则，交换两个结点的值。重复上述步骤直到根节点为止。

2.3创建堆

给定一个数组，逻辑上是一棵完全二叉树，通过计算，构建成堆。

我们从倒数第一个非叶子结点的子树开始调整，一直调整到根节点的树，就可以调整成堆。

3.应用

3.1 优先级队列

我们在这里以大堆为例子，实现大堆的添加，取最大元素
往优先队列中添加一个值，我们需要堆仍然保持结构，所以需要向上调整
取出优先队列中的最大值，然后将最后一个元素挪到队首，同时需要保持堆的结构就需要向下调整

public class MyPriorityQueue {
    // 以大堆为例子
    private int[] array = new int[30];
    private int size = 0;

    public int getSize() {
        return size;
    }

    public void offer(int val) {
        // 将新添加进来的元素放在size位置
        array[size] = val;
        size++;
        // 把新加入的元素进行向上调整
        shiftUp(array, size - 1);
    }
	
    // 向上调整
    private static void shiftUp(int[] array, int index) {
        int child = index;
        int parent = (index - 1) / 2;
        while (child > 0) {
            if (array[parent] < array[child]) {
                int tmp = array[parent];
                array[parent] = array[child];
                array[child] = tmp;
            } else {
                break;
            }
            child = parent;
            parent = (child - 1) / 2;
        }
    }

    // 将队首元素删掉并返回，同时保持堆结构
    public int poll() {
        int result = array[0];
        array[0] = array[size - 1];
        size--;
        shiftDown(array, size, 0);
        return result;
    }
	
    // 向下调整
    private static void shiftDown(int[] array, int size, int index) {
        int parent = index;
        int child = 2 * parent + 1;
        while (child < size) {
            if (child + 1 < size && array[child] < array[child + 1]) {
                child = child + 1;
            }
            if (array[parent] < array[child]) {
                int tmp = array[parent];
                array[parent] = array[child];
                array[child] = tmp;
            } else {
                break;
            }
            parent = child;
            child = 2 * parent + 1;
        }
    }

    public int peek(){
        return array[0];
    }
    public boolean isEmpty(){
        return size == 0;
    }
}

3.2Top K问题

直接利用上面构建的优先级队列来实现。

要找堆中前k大或者前k小的问题，很自然的是把前k个取出来。

class test {
    public static void main(String[] args) {
        // 找出 前三大 的
        int[] arr = new int[]{9, 5, 2, 7, 8, 3};
        MyPriorityQueue queue = new MyPriorityQueue();
        for (int i = 0; i < arr.length; i++) {
            queue.offer(arr[i]);
        }
        int k = 3;
        for (int i = 0; i < k ; i++) {
            System.out.print(queue.poll() + " ");
        }
    }
}

3.3堆排序

在传进来数组上直接搞一个大堆，然后将堆的第一个和当前堆最后一个交换。（注意，堆在不断缩小，有序性在不断增加）这样不断重复，就能够从后到前使数组有序。

注意：升序建立大堆，降序建立小堆

public static void heapSort(int[] array) {
    // 1.用传进来的数组建立一个大堆
    createHeap(array);
    // 循环 array.length - 1 次,最后一次它本身，不用交换
    for (int i = 0; i < array.length - 1; i++) {
        // 2.将第一个和最后一个（相对）元素交换
        //    相对位置的最后一个下标始终向前移动一个位置
        // 堆的个数
        int heapSize = array.length - i;
        swap(array, 0, heapSize - 1);
        heapSize--;
        // 3.将剩余部分重新向下调整使保持堆结构
        shiftDown(array, heapSize, 0);
    }
}

private static void swap(int[] array, int a, int b) {
    int tmp = array[a];
    array[a] = array[b];
    array[b] = tmp;
}


private static void createHeap(int[] array) {
    // 从后往前对每一个元素进行向下调整
    for (int index = (array.length - 1 - 1) / 2; index >= 0; index--) {
        shiftDown(array, array.length, index);
    }
}

public static void shiftDown(int[] array, int size, int index) { // 大堆
    // 将需要调整的位置初始化为parent
    int parent = index;
    int child = parent * 2 + 1;
    while (child < size) { // 保证 child 不能越界
        // 使 child 一定是左右孩子中最大的那个
        if (child + 1 < size && array[child + 1] > array[child]) {
            child = child + 1;
        }
        // 然后用最大的那个 child 和 parent 比较
        if (array[parent] < array[child]) {
            int tmp = array[parent];
            array[parent] = array[child];
            array[child] = tmp;
        } else {
            // 结束
            break;
        }
        parent = child;
        child = 2 * parent + 1;
    }

}