堆和优先队列 —— 个人解读

什么是优先队列

• 普通队列：先进先出，后进后出
• 优先队列：出队顺序和入队顺序无关；和优先级相关

堆的基本结构

采用堆作为优先队列的底层是一种高效的实现，因为堆作为底层，时间复杂度入队和出队都是O(logn)级别。

二叉堆的性质：

• 堆中某个节点的值总是不大于其父节点的值
• 一个（最大）二叉堆是一个具有最大堆特性的完全二叉树。

二叉堆是可用于实现高效优先队列ADT的数据结构之一。在优先队中，每一个元素都有一个优先级并且一个高优先级的元素总是比低优先级的先出头（如果有一样的优先级，像普通队列一样先进先出）。

用数组存储二叉堆（最大堆）

如图通过visualgo网站生成一个最大堆。
该图中标号的顺序是一个层序的顺序，可以用如下这样的一个数组来表示上图这样一个完全二叉树。

可以看到，用数组存储二叉堆存在这样的一个规律：

parent(i) = i/2
left child (i) = 2*i
right child (i) = 2*i+1

对于任意一个节点，它的左孩子所在的节点相应的索引就是这个节点索引的2倍，而右孩子就是这个节点索引的2倍+1,还有一个最重要的性质就是对于任意节点与它父亲节点存在这样的一种逻辑关系：parent(i) = i/2。

因为数组的索引从0开始，为了符合习惯，将其偏移后变成如下这样。

相应的规律也变为：

parent(i) = (i-1)/2
left child (i) = 2*i + 1
right child (i) = 2*i + 2

package 最大堆;

/**
 * 描述     最大堆
 *
 * @author lixinzhen
 * @create 2021/10/26 22:29
 */
public class MaxHeap<E extends Comparable<E>> {
    private Array<E> data;
    public MaxHeap(int capacity){
        data = new Array<>(capacity);
    }
    public MaxHeap(){
        data = new Array<>();
    }
    //返回堆中的元素个数
    public int size(){
        return data.getSize();
    }
    //返回一个布尔值，表示堆中是否为空
    public boolean isEmpty(){
        return data.isEmpty();
    }
    //返回完全二叉树的数组表示中，一个索引所表示的元素的父亲节点的索引
    private int parent(int index){
        if (index == 0)
            throw new IllegalArgumentException("index-0 doesn't have parent");
        return (index - 1)/2;
    }
    //返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
    private int leftChild(int index){
        return index *2 + 1;
    }
    //返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
    private int rightChild(int index){
        return index * 2 +2;
    }

}

向堆中添加元素（Sift Up）

 //向堆中添加元素
    public void add(E e) {
        data.addLast(e);
        siftUp(data.getSize() - 1);
    }

    private void siftUp(int k) {
        //父亲节点比当前节点小，上浮
        while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
            data.swap(k, parent(k));//交换元素
            k = parent(k);
        }
    }
     public void swap(int i, int j) {
        if (i < 0 || i >= size || j < 0 || j >= size)
            throw new IllegalArgumentException("Index is illegal");
        E t = data[i];
        data[i] = data[j];
        data[j] = t;
    }

从堆中取出元素（Sift Down)

将堆中最小的元素放到堆顶，并依次与左右孩子中最大的节点（大于自身节点）进行交换，直至大于孩子节点。

 //看堆中的最大元素
    public E findMax() {
        if (data.getSize() == 0)
            throw new IllegalArgumentException("Can not findMax when heap is empty");
        return data.get(0);
    }

    //取出堆中最大元素
    public E extractMax() {
        E ret = findMax();
        data.swap(0, data.getSize() - 1);//最小的元素与堆顶元素交换
        data.removeLast();//删除最大的元素
        siftDown(0);
        return ret;
    }

    private void siftDown(int k) {
        while (leftChild(k) < data.getSize()) {
            int j = leftChild(k);
            if (j + 1 < data.getSize() &&//判断是否存在右孩子
                    data.get(j + 1).compareTo(data.get(j)) > 0)//判断右孩子是否大于左孩子
                j = rightChild(k);//相当于j++
            //此时data[j]是leftChild和rightChild中的最大值
            if (data.get(k).compareTo(data.get(j)) >= 0)
                break;
            //如果当前节点小于左右孩子中最大的那个，则交换位置
            data.swap(k, j);
            k = j;
        }
    }

堆排序

将n个元素逐个插入到一个空堆中，算法复杂度是O(nlogn)。

public static <E extends Comparable<E>> void sort(E[] data){
        MaxHeap<E> maxHeap = new MaxHeap<>();
        for (E e:data){
            maxHeap.add(e);
        }
        //升序排列
        for (int i =data.length-1;i >=0;i --)
            data[i] = maxHeap.extractMax();
    }

replace和heapify

replace：取出堆中的最大元素，并且替换成元素e,这个过程的时间复杂度为O(logn)

    public E replace(E e){
        E ret = findMax();
        data.set(0,e);
        siftDown(0);
        return ret;
    }

heapify：将任意数组整理成堆的形状,这个过程的时间复杂度为O(n)

public  MaxHeap(E[] arr){
        data = new Array<>(arr);
        for (int i = parent(arr.length-1); i >=0 ; i--) {
            siftDown(i);
        }
    }

对于n个节点的二叉树（有h层），如果是满二叉树。那么

• 最后一层(h)节点最多有2^(h-1)或n/2
• 非叶子节点2^(h-1)-1
• 叶子节点有2^(h-1)

优化的堆排序（最大堆）

public static <E extends Comparable<E>> void sort2(E[] data) {
        if (data.length <= 1) {
            return;
        }
        for (int i = (data.length - 2) / 2; i >= 0; i--) {
            siftDown(data, i, data.length);
        }
        for (int i = data.length - 1; i >= 0; i++) {
            swap(data, 0, i);
            siftDown(data, 0, i);
        }
    }

    //对data[0,n)所形成的最大堆中，索引k的元素，执行siftDown
    private static <E extends Comparable<E>> void siftDown(E[] data, int k, int n) {
        while (2 * k + 1 < n) {
            int j = 2 * k + 1;//在此轮循环中，data[k]和data[j]交换位置
            if (j + 1 < n && data[j + 1].compareTo(data[j]) > 0)
                j++;
            //此时data[j]是leftChild和rightChild中的最大值
            if (data[k].compareTo(data[j]) >= 0)
                break;
            swap(data, k, j);
            k = j;
        }
    }

    public static <E> void swap(E[] arr, int i, int j) {
        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

基于堆的优先队列

首先来看下队列的基本数据结构：

public interface Queue<E> {
    int getSize();
    boolean isEmpty();
    void enqueue(E e);//入队
    E dequeue();//出队
    E getFront();
}

构建一个基于堆的优先队列数据结构

package 堆和优先队列;

/**
 * 描述     优先队列
 *
 * @author lixinzhen
 * @create 2021/10/31 17:34
 */
public class PriorityQueue<E extends Comparable<E>> implements Queue<E> {
    private MaxHeap<E> maxHeap;

    public PriorityQueue() {
        maxHeap = new MaxHeap<>();
    }

    @Override
    public int getSize() {
        return maxHeap.size();
    }

    @Override
    public boolean isEmpty() {
        return maxHeap.isEmpty();
    }

    @Override
    public E getFront() {
        return maxHeap.findMax();
    }
    @Override
    public void enqueue(E e) {
        maxHeap.add(e);
    }

    @Override
    public E dequeue() {
        return maxHeap.extractMax();
    }
}

Top K问题

top问题：

• 在N个元素中选出最大的K个元素
• 在N个元素中选出最小的K个元素

使用优先队列（采用最大堆），维护当前看的的最小的K个元素， 对于每一个新的数据，如果比这K个最小元素中最大的还小，则替换。

public class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < k; i++) {
            pq.enqueue(arr[i]);
        }
        for (int i = 0; i < arr.length; i++) {
            if (!pq.isEmpty() && arr[i] < pq.getFront()) {
                pq.dequeue();
                pq.enqueue(arr[i]);
            }
        }
        int[] res = new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = pq.dequeue();
        }
        return res;
    }
}