优先级队列(堆)的模拟实现代码解析

public int[] elem;
public int usedSize;

 elem 数组： 用于存储优先级队列的元素。

usedSize 变量： 用于表示当前优先级队列中已经使用的元素个数。

public PriorityQueue(int capacity) {
    elem = new int[capacity];
    usedSize = 0;
}

构造方法 PriorityQueue(int capacity)： 构造方法用于初始化 PriorityQueue 类的实例对象。 接受’capacity‘变量作为队列的初始容量，并初始化了 elem 和 usedSize 。

public void createHeap(int[] array) {
    for(int parent=(usedSize-1-1)/2;parent>=0;parent--){
        shiftDown(parent,usedSize);
    }
}

 createHeap(int[] array) 方法： 该方法用于将一个数组构建成最大堆。它遍历每棵子树的根节点，调用 shiftDown 方法，将数组调整为最大堆的形式。

public void swap(int i,int j){
    int tmp=elem[i];
    elem[i]=elem[j];
    elem[j]=tmp;
}

 swap(int i, int j) 方法： 交换elem数组中下标为'i','j'的值。

private void shiftDown(int parent,int len) {
    int child=parent*2+1;
    while (child<len) {
        if (child + 1 < usedSize && elem[child] < elem[child + 1]) {
            child = child + 1;
        }
        if (elem[child] > elem[parent]) {
            swap(child, parent);
            parent=child;
            child=parent*2+1;
        }else{
            break;
        }
    }
}

 shiftDown(int parent, int len) 方法： 向下调整的方法，用于维持最大堆的性质。从根节点开始，逐级将较大的子节点上移，直到满足最大堆的条件。

public void push(int val) {
    if (isFull()) {
        // 处理队列满的情况
        return;
    }
    elem[usedSize] = val;
    usedSize++;
    shiftUp(usedSize - 1);
}

 push(int val) 方法： 入队方法，将元素 val 加入到队列中。首先检查队列是否已满，如果满则return。否则，将元素添加到队列的末尾，然后通过调用 shiftUp 方法向上调整，以满足最大堆的性质。

 

private void shiftUp(int child){
    int parent=(child-1)/2;
    while (child>0){
        if(elem[child]>elem[parent]){
            swap(child,parent);
            child=parent;
            parent=(child-1)/2;
        }

    }
}

 shiftUp(int child) 方法： 向上调整的方法，用于维持最大堆的性质。从插入元素的位置开始，逐级将较大的父节点下移，直到满足最大堆的条件。

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

 isFull() 方法： 通过判断“usedSize==elem.length”，判断队列是否已满。

 

public void pollHeap() {
    if (isEmpty()) {
        // 处理队列空的情况
        return;
    }
    swap(0, usedSize - 1);
    shiftDown(0, usedSize - 1);
    usedSize--;
}

 pollHeap() 方法： 出队方法，删除队列中优先级最高的元素。首先检查队列是否为空，如果为空则不进行操作。否则，将堆顶元素与最后一个元素交换，然后通过调用 shiftDown 方法向下调整，以满足最大堆的性质。

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

 isEmpty() 方法： 判断队列是否为空。

public int peekHeap() {
    if(isEmpty()) {
        return -1;
    }
    return elem[0];
}

 peekHeap() 方法： 获取堆顶元素的值，如果队列为空则返回 -1。