优先级队列（堆的模拟实现）

概念

我们知道，队列是一种先进先出的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，就有可能让优先级高的元素先出队列，在这种情景下，无脑使用队列显然是不合适的。比方说：在玩手机游戏时，如果有来电，那么系统应该优先处理打来的电话

• 在这种情况下，数据结构提供两个最基本的操作：一个是返回最高优先级对象，一个是添加新的对象。 这种数据结构就是 优先级队列（PriorityQueue）

---

优先级队列的模拟实现

JDK1.8中的 PriorityQueue底层使用 堆 这种数据结构，而堆实际就是在完全二叉树的基础上进行了一些调整

---

堆的概念

堆分为小根堆和大根堆，以图的方式展示

• 小根堆：根结点数值 比 其左右孩子 都小

• 大根堆：根结点数值 比 其左右孩子 都大
  

说明：

• 只考虑根结点和它的左右孩子，即图中三角部分。三角部分满足堆的条件，那么它就是一个堆
  

---

堆的存储方式

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

注意：

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

• 将元素存储到数组中后，可以根据 二叉树的性质5 对树进行还原

完全二叉树的性质：对于一棵有 n 个结点的完全二叉树，对于序号为 i 的结点来说，有：
若 i > 0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
若 2i+1 < n，左孩子序号：2i+1，否则无左孩子
若 2i+2 < n，右孩子序号：2i+2，否则无右孩子

---

堆的基本操作

一、堆的创建

第一步：构建构造方法

代码：

private static final int DEFAULT_CAPACITY = 11;  
  
int[] queue;  
  
private int usedSize;//量化有效数据  
  
public MyPriorityQueue() {  
    this.queue = new int[DEFAULT_CAPACITY];  
}

---

第二步：初始化 queue 数组

• 为了方便测试功能，这里简单写一下，就不涉及扩容之类的操作了

代码：

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

---

第三步：创建堆（以大根堆为例）

思路：向下调整

图解：图中是以小根堆为例，但文中是构建大根堆，不要搞混

• 图中是只有根结点需要调整，但实际上传入的数组是随机的，计算机并不知道哪些子树本身就是大根堆，所以要每一棵子树都要调整一遍才可以

想法：

1. 从最后一层非叶结点的最后一棵子树开始 向下调整 。如图，从蓝色序列 ① 开始向下调整，调整完之后从 ② 随后是 ③④⑤…
2. 知道了最后一棵子树的下标，也就知道了后面要调整的子树的下标，即当前根结点下标减一

如何找到最后一棵子树的位置呢？
通过完全二叉树的性质来确定，拿到最后一个结点的下标，就能通过下标找到其父结点

算法：

1. 通过孩子结点（用指针 child 进行标记）找到最后一棵子树（用指针 parent 进行标记）
2. 找到左右孩子的最大值，用 child 与 parent 所指向的对象相比较，如果 child > parent ，那么两者进行交换，child 指向 parent ，parent 通过 child 来确定
3. 一直调整到 0 下标这颗树

细节补充：

• 想拿到最后一个子树的下标，就要拿到其孩子结点的下标。其孩子结点的下标即为数组长度 - 1 (child = usedSize - 1)，通过完全二叉树性质，其父结点下标为 parent = (child-1)/2
• 图解：
  

代码：

public void createHeap() {  
    for (int parent = (usedSize - 1 - 1) / 2; parent >= 0; parent--) {  
        shiftDown(parent, usedSize);  
    }  
}  
  
private void siftDown(int parent, int length) {  
    int child = 2 * parent + 1; //  
    // 如果存在左孩子，才能进入while语句  
    while (child < length) {  
        // 让child指针指向最大的孩子结点  
        if ((child + 1 < length) && (queue[child] < queue[child + 1])) { 
	        // 如果不存在右孩子，那么这个表达式可能会造成数组下标越界异常！  
            child = child + 1;  
        }  
        if (queue[child] > queue[parent]) {  
            swap(child,parent);// 交换  
            // 向下调整  
            // parent 指向 child            
            parent = child;  
            child = 2*parent+1;  
        }else {  
            break;  // 如果不大于，说明这棵子树符合堆结构，直接退出循环
        }  
  
    }  
}  

// 交换
private void swap(int child, int parent) {  
    int tmp = queue[child];  
    queue[child] = queue[parent];  
    queue[parent] = tmp;  
}

• 向下调整建堆的时间复杂度为：O(N)
• 也可以使用向上调整的方式建立堆，但这种建堆方式的时间复杂度为：O(N logN)*

曾困扰过我的一些问题

1. 一棵子树有两个孩子，那么 child 指针应该指向哪个孩子结点呢？
   • 让 child 指向左右孩子中最大的那一个孩子结点，因为只有这个最大的孩子结点才有资格去和 parent 结点相比较。如果这个 child 结点数值大于 parent 结点数值，两者交换后，child 结点的左右子树就无法确定是堆结构，所以要让 parent 指向 child （对于 child 结点来说，它本身也是一个根结点，它也有它的左右子树），再去判断 child 这棵子树是否符合堆结构，即向下调整

如图：

• 在图一中，蓝框中的树是已经调整完毕的，现在要调整下标1的树。可以看到，1下标树的左子树中存在比根结点15还要大的孩子结点18、25，如果只是将49调整上去，就会发生图二中的情况，我们只是调整橙框中的树，并没有向下调整，导致这棵子树不符合堆结构
  • 核心在于，有数值进行交换的两个结点，无法确保根结点与其下属子树的值是否符号堆的条件，交换过后的子树具有不确定性。要确保其下属子树符号根堆结构，就有了 parent 位置更改为 child ，再去判断其子树是否符号堆条件

2. 循环结束条件疑问：不断向下调整，那么什么时候才结束呢？
   • 通过二叉树性质5可知，如果已知根结点下标为 i ，树结点个数为 n ，那么若 2*i+1 < n 说明有左孩子，反之则无左孩子；因为是完全二叉树，没有左孩子，必然没有右孩子。循环条件即从这一条性质而来。

---

第四步：堆的插入

思路：向上调整

• 堆的底层是用数组实现的，所以直接在数组有效数据的后面插入数据即可。
• 直接用插入进来的数据与根结点相比较（因为插入之前已经是堆结构了，根结点左右孩子是固定的，如果插入的数值比根结点还大，说明这个数值肯定比原根结点的左孩子大），若大于根结点，两者交换

注意：

• 插入前判断数组是否已满，若已满，则进行扩容操作

算法逻辑

• 这里的向上调整算法逻辑，其实就类似简单插入排序

代码：

public void offer(int val) {  
    if (isFull()) {  
        grow();  
    }  
    int i = usedSize;  
    if (i == 0) {  
        queue[0] = val;  
    }else {  
        siftUp(val,i);  
    }  
    usedSize++;  
}  
  
private void siftUp(int val, int child) {  
    // i 为插入下标  
    // 选择排序  
    while (child > 0) {  
        int parent = (child-1)/2;  
        int e = queue[parent];  
        if (val > e) {  
            queue[child] = e;  
            child = parent;  
        }else {  
            break;  
        }  
    }  
    queue[child] = val;  
}  
  
private void grow() {  
    queue = Arrays.copyOf(queue,queue.length*2);  
}  
  
private boolean isFull() {  
    return usedSize == queue.length;  
}

---

第五步：堆的删除

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

思路：

1. 将堆顶元素与堆中最后一个元素交换
2. 有效数据个数减 1
3. 对堆顶元素进行向下调整

代码：

public int poll() {  
    if (usedSize == 0) {  
        throw new IndexOutOfBoundsException("数组为空");  
    }  
    // 返回堆顶元素  
    int result = queue[0]; 
	// 拿到最后元素下标，并且有效数据个数减一
    int size = --usedSize; 
    // 交换堆顶元素与最后一个元素
    swap(0,size);  
	// 对堆顶元素进行向下调整
    siftDown(0,size);  
    return result;  
}