数据结构堆与优先级队列

文章目录

- 📕1. 堆(Heap)
- - - ✏️1.1 堆的概念
    - ✏️1.2 堆的存储方式
    - ✏️1.3 堆的创建
    - ✏️1.4 堆的插入
    - ✏️1.5 堆的删除
- 📕2. 优先级队列(PriorityQueue)
- - - ✏️2.1 堆与优先级队列的关系
    - ✏️2.2 优先级队列的构造方法
    - ✏️2.3 优先级队列的常用方法
- 3. Java对象的比较
- - - 3.1 基于Comparble接口类的比较
    - 3.2 基于比较器比较

📕1. 堆(Heap)

✏️1.1 堆的概念

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

堆满足以下两个性质:

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

在这里插入图片描述

✏️1.2 堆的存储方式

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

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

在这里插入图片描述
将元素存储到数组中后,假设i为节点在数组中的下标,则有:

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

✏️1.3 堆的创建

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

我们将想要调整的节点标记为parent,child为该节点的左孩子(如果有孩子节点,则一定是现有左孩子)
如果有左孩子节点,则判断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 堆的插入

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

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

在这里插入图片描述

向上调整:

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 堆的删除

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

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

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

📕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 是最⼩的
	
	@Override
	public 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);
}

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

用户自定义比较器类，实现Comparator接口
重写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 是最⼩的
	
	@Override
	public 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 ⽐较⼤
	}
}