📕1. 堆(Heap)

✏️1.1 堆的概念

堆（Heap）是一种特殊的完全二叉树，它满足父节点的值总是不大于或不小于其子节点的值。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆满足以下两个性质:

1.堆中某个节点的值总是不大于或不小于其根节点的值
2. 堆总是一棵完全二叉树

✏️1.2 堆的存储方式

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

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

将元素存储到数组中后,假设i为节点在数组中的下标,则有:

1. 如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2
2. 如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子
3. 如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子

✏️1.3 堆的创建

想要创建堆,我们首先要了解向下调整(这里以创建小根堆为例):

1. 我们将想要调整的节点标记为parent,child为该节点的左孩子(如果有孩子节点,则一定是现有左孩子)
2. 如果有左孩子节点,则判断child<size(数组元素个数),然后进行以下操作,直到child<size条件不成立
   2.1 判断parent的右孩子是否存在,找到左右孩子中最小的那个,用child标记.(如果右孩子比左孩子小,child+=1)
   2.2 将parent与child比较,如果parent<child,则调整结束;否则进行元素交换,交换完之后,有可能新构建的子树又不满足小根堆,所以需要将parent = child,child = parent * 2 + 1. 然后继续重复2操作.这便是向下调整.

    public void siftDown(int[] arr,int parent){//此时child标记的左孩子,因为parent右孩子结点的话只能先有左孩子int child = parent * 2 + 1;int size = arr.length;while(child < size){// 如果右孩⼦存在，找到左右孩⼦中较⼩的孩⼦,⽤child进⾏标记if (child+1 < size && arr[child] < arr[child+1]){child+=1;}// 如果双亲⽐其最⼩的孩⼦还⼩，说明该结构已经满⾜堆的特性了if (arr[parent] <= arr[child]){break;}else {// 将双亲与较⼩的孩⼦交换int t = arr[parent];arr[parent] = arr[child];arr[child] = t;// parent中⼤的元素往下移动，可能会造成⼦树不满⾜堆的性质，因此需要继续向下调整parent = child;child = parent * 2 + 1;}}}

了解完向下调整,那给你任意一些数据,那我们该如何创建成小根堆呢?

public void createHeap(int[] arr){// 找倒数第⼀个⾮叶⼦节点，从该节点位置开始往前⼀直到根节点，遇到⼀个节点，应⽤向下调整int root = (arr.length-2)/2;for (; root >= 0 ; root--) {siftDown(arr,root);}
}

还需要注意的是,建堆的时间复杂度为O(N);

✏️1.4 堆的插入

堆的插入总共需要两个步骤;

1. 先将元素放入到数组最后一个空间中(数组长度不够时需要扩容)
2. 将新插入的节点利用向上调整,直到满足堆的性质

向上调整:

public void siftUp(int child){//以创建小根堆为例//找到child的根节点int parent = (child-1)/2;while(child > 0){// 如果双亲⽐孩⼦小，parent满⾜堆的性质，调整结束if (arr[parent] < arr[child]){break;}else {// 将双亲与孩⼦节点进⾏交换int tmp = arr[parent];arr[parent] = arr[child];arr[child] = arr[tmp];}// ⼩的元素向下移动，调整后的⼦树可能不满⾜堆的性质，因此需要继续向上调增child = parent;parent = (child-1)/2;}}

插入数据:

/**
* 插入数据：
* 每次插入到当前堆的最后一个(数组的最后一个)，然后向上调整
*/public void offer(int val) {if(isFull()) {elem = Arrays.copyOf(elem,2*elem.length);}elem[size] = val;//调整siftUp(size);size++;}

✏️1.5 堆的删除

堆的插入总共需要两个步骤;

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

注意：堆的删除⼀定删除的是堆顶元素

📕2. 优先级队列(PriorityQueue)

之前我们已经学习过队列了,队列是一种先进先出(FIFO)的数据结构,但有些情况下，操作的数据可能带有优先级,出队列时，可能需要优先级高的元素先出队列 . 比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话.该场景下，使用队列显然不合适，因此数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，⼀个是添加新的对象。这种数据结构就是优先级队列(PriorityQueue).

✏️2.1 堆与优先级队列的关系

首先大家要知道一点 , 堆是一种数据结构 , 而优先级队列也是一种数据结构 , 二者是完全单独且不同的数据结构.
优先队列本身就是一种数据结构，它的着重点是优先，而不是队列。优先是目标，队列只是形式.
优先级队列不仅可以用堆来实现 , 用链表也是可以模拟实现的 , 只不过在JDK1.8中 , PriorityQueue的底层实现使用了堆这种数据结构.

✏️2.2 优先级队列的构造方法

注意：默认情况下，PriorityQueue队列是小堆，如果需要大堆需要用户提供比较器

✏️2.3 优先级队列的常用方法

优先级队列的扩容说明：
• 如果容量小于64时，是按照oldCapacity的2倍方式扩容的
• 如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的
• 如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容

3. Java对象的比较

在SE阶段中,我们介绍了引用类型变量使用equals()方法进行比较 , 基本数据类型变量使用大于号小于号进行比较 , 故以上两种方法此处不再赘述.

3.1 基于Comparble接口类的比较

Comparble是JDK提供的泛型的比较接口类，源码实现具体如下：

public interface Comparable<E> {// 返回值:// < 0: 表⽰ this 指向的对象⼩于 o 指向的对象// == 0: 表⽰ this 指向的对象等于 o 指向的对象// > 0: 表⽰ this 指向的对象⼤于 o 指向的对象int compareTo(E o);
}

对于用户定义类型，如果要想按照大小的方式进行比较时：
在定义类时，实现Comparble接口即可，然后在类中重写compareTo方法。

public class Card implements Comparable<Card> {public int rank; // 数值public String suit; // 花⾊public Card(int rank, String suit) {this.rank = rank;this.suit = suit;}// 根据数值⽐较，不管花⾊// 这⾥我们认为 null 是最⼩的@Overridepublic int compareTo(Card o) {if (o == null) {return 1;}return this.rank - o.rank;}public static void main(String[] args){Card p = new Card(1, "♠");Card q = new Card(2, "♠");Card o = new Card(1, "♠");System.out.println(p.compareTo(o)); // == 0，表⽰牌相等System.out.println(p.compareTo(q)); // < 0，表⽰ p ⽐较⼩System.out.println(q.compareTo(p)); // > 0，表⽰ q ⽐较⼤}
}

3.2 基于比较器比较

Comparator是java.util 包中的泛型接口类 , 源码如下:

public interface Comparator<T> {// 返回值:// < 0: 表⽰ o1 指向的对象⼩于 o2 指向的对象// == 0: 表⽰ o1 指向的对象等于 o2 指向的对象// > 0: 表⽰ o1 指向的对象等于 o2 指向的对象int compare(T o1, T o2);
}

按照比较器方式进行比较，具体步骤如下：

1. 用户自定义比较器类，实现Comparator接口
2. 重写Comparator中的compare方法

import java.util.Comparator;class Card {public int rank; // 数值public String suit; // 花⾊public Card(int rank, String suit) {this.rank = rank;this.suit = suit;}
}class CardComparator implements Comparator<Card> {// 根据数值⽐较，不管花⾊// 这⾥我们认为 null 是最⼩的@Overridepublic int compare(Card o1, Card o2) {if (o1 == o2) {return 0;}if (o1 == null) {return -1;}if (o2 == null) {return 1;}return o1.rank - o2.rank;}public static void main(String[] args){Card p = new Card(1, "♠");Card q = new Card(2, "♠");Card o = new Card(1, "♠");// 定义⽐较器对象CardComparator cmptor = new CardComparator();// 使⽤⽐较器对象进⾏⽐较System.out.println(cmptor.compare(p, o)); // == 0，表⽰牌相等System.out.println(cmptor.compare(p, q)); // < 0，表⽰ p ⽐较⼩System.out.println(cmptor.compare(q, p)); // > 0，表⽰ q ⽐较⼤}
}