Java~堆(heap)的基本概念、操作及实现，冲刺7天拿下Offer

}else {

break;

}

patent = child;

child = 2 * patent + 1;

}

}

//向上调整

public static void shiftUp(int[] array, int size, int index) {

int child = index;

int parent = (child - 1)/2;

while (child > 0) {

if(array[child] < array[parent]) {//孩子的值小于parent的值

int temp = array[child];

array[child] = array[parent];

array[parent] = temp;

}else {

break;

}

child = parent;

parent = (child - 1)/2;

}

}

建大堆是每次循环找大的值，而建小堆就是每次循环找小的值。

同理建小堆的时候用向下调整还是会出现失败反例（最小值出现在后几个数字），而使用向上调整是不会出现这种情况的。

**建小堆的时候用向下调整还是从前到后遍历数组。（因为index是根结点）

使用向上调整建立小堆的时候还是从后到前遍历数组。（因为index是最后一个叶子结点）**

优先级队列的实现：

优先级队列本质还是队列只是我们在实现offer和poll操作的时候分别进行了向上调整和向下调整。（当然我们使用建大堆的向上和向下调整的话是值最高的优先级最高，最先出队列）

public class MyPriorQueue {

private int[] array = new int[100];

private int size = 0;

public void offer(int data) {

this.array[size] = data;

size ++;

shiftUp(array, size, size - 1);

}

private void shiftUp(int[] array, int size, int index) {

int child = index;

int parent = (child - 1)/2;

while (child > 0) {

if(array[child] > array[parent]) {

int temp = array[child];

array[child] = array[parent];

array[parent] = temp;

}else {

break;

}

child = parent;

parent = (child - 1)/2;

}

}

public Integer poll() {

if(size <= 0) {

return null;

}

int ret = this.array[0];

this.array[0] = this.array[size - 1];

size --;

shiftDown(array, size, 0);

return ret;

}

private 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 += 1;

}

if(array[child] > array[parent]) {

int temp = array[child];

array[child] = array[parent];

array[parent] = temp;

}else {

break;

}

parent = child;

child = 2 * parent + 1;

}

}

public Integer peek() {

if(size <= 0) {

return null;

}

return array[0];

}

public boolean empty() {

return size == 0;

}

/* public void display() {

for (int i:this.array

) {

System.out.print(i + " ");

}

System.out.println();

}*/

public int length() {

return size;

}

}

**时间复杂度分析：

入队列-》向上调整O(logN)

出队列-》向下调整O(logN)

取队首元素O(1)

建堆操作的时间复杂度是O(N)**

**PriorityQueue 的使用:

（也就是库优先级队列）**

public static void main(String[] args) {

PriorityQueue pq = new PriorityQueue<>();

int[] nums = new int[] {3, 7, 4, 8, 3, 2, 9};

for (int i:nums

) {

pq.offer(i);

}

while (!pq.isEmpty()) {

System.out.print(pq.poll() + " ");

}

}

**我们要注意库函数里的优先级队列使用的是建小堆的向上调整和向下调整。

库里的原始优先级队列遵循值越小，优先级越高思想。

当然我们也可以自己定义一个比较器对象，借助比较器我们自己定义谁优先谁不优先。**

static class comp implements Comparator {

@Override

public int compare(Integer o1, Integer o2) {

// return o1 - o2;

return o2 - o1;

}

}

public static void main(String[] args) {

PriorityQueue pq = new PriorityQueue<>(new comp());

int[] nums = new int[] {3, 7, 4, 8, 3, 2, 9};

for (int i:nums

) {

pq.offer(i);

}

while (!pq.isEmpty()) {

System.out.print(pq.poll() + " ");

}

}

TopK 问题、堆排序：

**只要掌握了优先级队列，这两问题是很简单的。

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

最后

转存中…(img-AqZFu7ri-1711138532174)]
[外链图片转存中…(img-VKn6fLxN-1711138532175)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-g3gexAAS-1711138532175)]

最后

[外链图片转存中…(img-R9Idr4gA-1711138532176)]

[外链图片转存中…(img-0Y9jUN6x-1711138532176)]

[外链图片转存中…(img-Br1ny2fd-1711138532177)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录