我的编程经历（35）----------优先级队列（堆）

本篇主要总结堆的相关内容。

首先要理解什么是堆。堆的底层其实是一个数组或者顺序表的结构，但是它的逻辑结构是一颗完全二叉树，并且满足某个节点的值总是不大于或者不小于其父亲节点的值：

如上图所示，即为一个最小堆：父亲节点的值始终小于其孩子节点的值，最大堆则反之。其在内存中的存储形式如右图所示。则在对该完全二叉树进行层序遍历时，必定于数组的遍历结果是相同的，此时就满足堆的性质。

由于其逻辑结构如二叉树，且二叉树存在如下性质：

已知父亲节点层序遍历下标为n，若其有左右孩子节点，则左孩子节点下标为：2n + 1；其右孩子的下标节点为：2n + 2。

因此给出一个数组，便能够根据以上性质创建一个堆，这里以大根堆举例：

public class Heap {
    public int[] elem;
    public int usedSize;

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

    public void getNum(int[] array){
        for (int i = 0; i < array.length; i++) {
            elem[i] = array[i];
            usedSize++;
        }
    }

    public void getHeap(){
        for (int parent = (usedSize - 1 - 1) / 2; parent >= 0; parent--) {
            outHeap(parent, usedSize);
        }
    }

    public void outHeap(int parent, int len){
        int child = 2 * parent + 1;
        while (child < len){
            if (child + 1 < len && elem[child] < elem[child + 1]){
                child++;
            }
            if (elem[child] > elem[parent]){
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                parent = child;
                child = parent * 2 + 1;
            }
            else {
                break;
            }
        }
    }

与其他数据结构一样，也可以对堆实现数据的插入与删除：

//插入新元素
    public void shift(int val){
        if (isFull()){
            elem = Arrays.copyOf(elem, elem.length*2);
        }
        elem[usedSize] = val;
        usedSize++;
        shiftDown(--usedSize);
    }
    //向上调整
    private void shiftDown(int child){
        int parent = (child - 1) / 2;
        while (child > 0){
            if (elem[parent] < elem[child]){
                int tmp = elem[parent];
                elem[parent] = elem[child];
                elem[child] = tmp;
                child = parent;
                parent = (child - 1) / 2;
            }
            else {
                break;
            }
        }
    }

    //先判断是否为满
    public boolean isFull(){
        return usedSize == elem.length;
    }

    //删除节点
    public void pop(){
        if (isEmpty()){
            return;
        }
        int tmp = elem[0];
        elem[0] = elem[usedSize - 1];
        elem[usedSize - 1] = tmp;
        usedSize--;
        outHeap(0, usedSize);
    }

    //是否为空
    public boolean isEmpty(){
        return usedSize == 0;
    }

   

以上是用代码实现一个堆。在实际应用过程中，更多的是使用Priority Queue接口。在使用时要注意：

1.该接口所放置的元素必须是要能够比较的；

2.不能放入null；

3.要导入该接口所在的包；

4.该接口与其他接口一样，在使用时要调用其构造方法。但是该接口的不带参数的构造方法默认创建的优先级队列容量为11。

因此可以利用该接口实现找出一组数据中前k个最大值：

import java.util.PriorityQueue;
import java.util.Queue;

public class Other {

    //前k个最大值
    public int[] maxK(int[] array, int k){
        int[] ret = new int[k];
        if (array == null || k == 0){
            return ret;
        }
        Queue<Integer> priorityQueue = new PriorityQueue<>(k);
        for (int i = 0; i < k; i++){
            priorityQueue.offer(array[i]);
        }
        for (int i = k; i < array.length; i++){
            if (priorityQueue.peek() < array[i]){
                priorityQueue.poll();
                priorityQueue.offer(array[i]);
            }
        }
        for (int i = 0; i < k; i++){
            ret[i] = priorityQueue.poll();
        }
        return ret;
    }
}

------------------------最后编辑于2023.5.12下午六点左右