7. 堆
7.1 堆的定义
堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组实现。
堆的特性：
- 它是完全二叉树，除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的，那么要求左满右不满。
-
它通常用数组来实现。
具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子结点则分别在位置4,5,6和7，以此类推。
如果一个结点的位置为k，则它的父结点的位置为[k/2],而它的两个子结点的位置则分别为2k和2k+1。这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动：从a[k]向上一层，就令k等于k/2,向下一层就令k等于2k或2k+1。
- 每个结点都大于等于它的两个子结点。这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。
7.2 堆的API设计
7.3 堆的实现_大顶堆
7.3.1 insert插入方法的实现
堆是用数组完成数据元素的存储的，由于数组的底层是一串连续的内存地址，所以我们要往堆中插入数据，我们只能往数组中从索引1处开始，依次往后存放数据，但是堆中对元素的顺序是有要求的，每一个结点的数据要大于等于它的两个子结点的数据，所以每次插入一个元素，都会使得堆中的数据顺序变乱，这个时候我们就需要通过一些方法让刚才插入的这个数据放入到合适的位置。
所以，如果往堆中新插入元素，我们只需要不断的比较新结点a[k]和它的父结点a[k/2]的大小，然后根据结果完成数据元素的交换，就可以完成堆的有序调整。
7.3.2 delMax删除最大元素方法的实现
由堆的特性我们可以知道，索引1处的元素，也就是根结点就是最大的元素，当我们把根结点的元素删除后，需要有一个新的根结点出现，这时我们可以暂时把堆中最后一个元素放到索引1处，充当根结点，但是它有可能不满足堆的有序性需求，这个时候我们就需要通过一些方法，让这个新的根结点放入到合适的位置。
7.3.3 堆的实现代码
package com.ynu.Java版算法.U7_堆.T1_堆的实现_大顶堆;
public class Heap<T extends Comparable<T>> {
// 存储堆中的元素 数组存储元素
private T[] items;
// 堆的大小
private int N;
public Heap(int maxSize) {
items = (T[]) new Comparable[maxSize+1];
N = 0;
}
// 判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i, int j){
return items[i].compareTo(items[j]) < 0;
}
//交换堆中i索引和j索引处的值
private void exch(int i,int j){
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
//往堆中插入一个元素
public void insert(T t){
items[++N] = t;
swim(N); // 上浮新插入的元素
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k){
//如果已经到了根结点，就不需要循环了
while (k > 1){
//比较当前结点和其父结点
if (less(k/2,k)){
//父结点小于当前结点，需要交换
exch(k/2,k);
}
k = k/2;
}
}
//删除堆中最大的元素,并返回这个最大元素
public T deleteMax(){
T max = items[1];
// 交换索引1和索引N处的元素
exch(1,N);
// 删除最后的元素
items[N--] = null;
// 下层
sink(1);
return max;
}
private void sink(int i) {
//如果当前已经是最底层了，就不需要循环了
while (2*i <= N){
// 找到子节点中的较大者
int max;
if (2*i+1<=N){ // 存在右子节点
max = less(2*i,2*i+1)?2*i+1:2*i;
}else { // 不存在右子节点
max = 2*i;
}
//比较当前结点和子结点中的较大者，如果当前结点不小，则结束循环
if (!less(i,max)){
break;
}
exch(i,max);
i = max;
}
}
}
7.4 堆的实现_小顶堆
其实差不了太多。懒得写了。
7.5 堆排序
- 树的入门
实现步骤：
-
构造堆；
-
得到堆顶元素，这个值就是最大值；
-
交换堆顶元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置；
-
对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶；
-
重复2~4这个步骤，直到堆中剩一个元素为止。
API设计：
7.5.1 堆构造过程
方法一:
堆的构造，最直观的想法就是另外再创建一个和新数组数组，然后从左往右遍历原数组，每得到一个元素后，添加到新数组中，并通过上浮，对堆进行调整，最后新的数组就是一个堆。
方法二:
上述的方式虽然很直观，也很简单，但是我们可以用更聪明一点的办法完成它。创建一个新数组，把原数组0length-1的数据拷贝到新数组的1length处，再从新数组长度的一半处开始往1索引处扫描（从右往左），然后对扫描到的每一个元素做下沉调整即可。
堆构造完毕，堆有序。
7.5.2 堆排序过程
对构造好的堆，我们只需要做类似于堆的删除操作，就可以完成排序。
-
将堆顶元素和堆中最后一个元素交换位置；
-
通过对堆顶元素下沉调整堆，把最大的元素放到堆顶(此时最后一个元素不参与堆的调整，因为最大的数据已经到了数组的最右边)
-
重复1~2步骤，直到堆中剩最后一个元素。
结果，已排序
7.5.3 代码实现
package com.ynu.Java版算法.U7_堆.T3_堆排序;
//堆排序代码
public class HeapSort {
//对source数组中的数据从小到大排序
public static void sort(Comparable[] source){
//1.创建一个比原数组大1的数组
Comparable[] heap = new Comparable[source.length + 1];
//2.构建堆 -- 大顶堆了
createHeap(source,heap);
//3.堆排序
//3.1定义一个变量，记录heap中未排序的所有元素中最大的索引
int N = heap.length - 1;
while (N!=1){
//3.2交换heap中索引1处的元素和N处的元素 当前索引为1的元素已经是最大的元素了
exch(heap,1,N);
N--;
sink(heap,1,N);
}
//4.heap中的数据已经有序，拷贝到source中
System.arraycopy(heap,1,source,0,source.length);
}
//根据原数组source，构造出堆heap
// String也是实现过Comparable接口的类，所以可以传进来。 是多态的应用。
private static void createHeap(Comparable[] source,Comparable[] heap){
//1.把source中的数据拷贝到heap中，从heap的1索引处开始填充
System.arraycopy(source,0,heap,1,source.length);
//2.从heap索引的一半处开始倒叙遍历，对得到的每一个元素做下沉操作
for (int i = (heap.length - 1) / 2; i > 0 ; i--) {
sink(heap,i,heap.length-1);
}
}
//判断heap堆中索引i处的元素是否小于索引j处的元素
private static boolean less(Comparable[] heap,int i,int j ){
return heap[i].compareTo(heap[j]) < 0;
}
//交换heap堆中i索引和j索引处的值
private static void exch(Comparable[] heap,int i,int j){
Comparable temp = heap[i];
heap[i] = heap[j];
heap[j] = temp;
}
//在heap堆中，对target处的元素做下沉，范围是0~range
private static void sink(Comparable[] heap,int target,int range){
// 没有子节点了就退出循环
while (2*target <= range){
//1.找出target结点的两个子结点中的较大值
int max = 2*target;
if (2*target +1 <= range){ // 存在右子节点
if (less(heap,2*target,2*target + 1)){
max = 2*target + 1;
}
}
//2.如果当前结点的值小于子结点中的较大值，则交换
if (less(heap,target,max)){
exch(heap,target,max);
}
//3.更新target的值
target = max;
}
}
}
package com.ynu.Java版算法.U7_堆.T3_堆排序;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
HeapSort.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
7.6 Java中的PriorityQueue实现堆
Java中PriorityQueue通过二叉小顶堆实现，可以用一棵完全二叉树表示。PriorityQueue位于Java util包中，实际上这个队列就是具有“优先级”。既然具有优先级的特性，那么就得有个前后排序的“规则”。所以其接受的类需要实现Comparable 接口。该队列线程安全，不允许null值，入队和出队的时间复杂度是O（log(n)）。
PriorityQueue 默认是小根堆，大根堆需要重写比较器。对与大根堆，就要借助于comparator比较器，来实现大根堆。
实现方法有两种
第一种: 匿名内部类
PriorityQueue<Integer>bigHeap=new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
第二种: lambda表达式
PriorityQueue<Integer> bigHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
堆排序:
package com.ynu.Java版算法.U7_堆.T4_API实现堆排序;
import org.junit.Test;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
public class Main {
// 1. 大顶堆 实现升序
@Test
public void test() {
String[] arr = {"B", "D", "C", "F", "E", "G", "H", "J", "I", "K", "A"};
// 构建空大顶堆
PriorityQueue<String> heap = new PriorityQueue<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);
}
});
// 把元素放进大顶堆
for (String s : arr) {
heap.offer(s);
}
// 堆排序 —— 升序
int k = arr.length - 1;
int size = heap.size();
for (int i = 0; i < size; i++) {
arr[k--] = heap.poll();
}
System.out.println(Arrays.toString(arr));
}
// 1. 小顶堆 实现升序
@Test
public void test1() {
String[] arr = {"B", "D", "C", "F", "E", "G", "H", "J", "I", "K", "A"};
// 1.构建空的小顶堆
PriorityQueue<String> heap = new PriorityQueue<>((o1,o2)->o1.compareTo(o2));
// 2.元素放进小顶堆
for (String s : arr) {
heap.offer(s);
}
// 3.堆排序 升序排列
int k = 0;
int size = arr.length;
for (int i = 0; i < size; i++) {
arr[k++] = heap.poll();
}
System.out.println(Arrays.toString(arr));
}
}
