堆
基础概念
堆的定义
堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。
堆的特性
- 它是完全二叉树，际了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的，那么要求左满右不满。
- 用数组实现（且通常从索引为1处开始插入，废弃了索引0）
- 将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子结点则分别在位置4,5,6和7，以此类推。
- 如果一个结点的位置为k，则它的父结点的位置为
k/2,而它的两个子结点的位置则分别为2k和2k+1。这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动:从a[k]向上一层，就令k等于k/2,向下一层就令k等于2k或2k+1。
- 每个结点都大于等于它的两个子结点。这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。
堆的种类
- 大顶堆：arr[i] >= arr[2i] && arr[i] >= arr[2i+1]
- 每个结点的值都小于等于它的子节点
- 小顶堆：arr[i] <= arr[2i] && arr[i] <= arr[2i+1]
- 每个结点的值都大于等于它的子节点
堆的构造（这里以构造大顶堆为例来构造）
堆的API设计
重要方法方法思路详解
- insert -- 往堆中插入元素
- 直接往数组中放入值，破坏了原本的堆的有序结构，使用上浮算法调整
- delMax -- 删除最大元素
- 因为删除最大元素，会改变堆的有序结构，所以我们要先交换要删除最大的元素和最后一个元素的位置
- 使用下沉算法，调整堆，使堆成为有序结构
- 然后此时最后一个元素就是我们要删除的元素，我们直接让它指向null，这样就实现了删除最大的元素
- 元素个数减一
- swim -- 上浮算法
- 不断让插入的值和和它的父节点比，比父节点大，就上移，直到比父节点小，比父节点小的时候，插入值的位置就是正确的了
- sink -- 下沉算法
- 循环遍历从k开始，找出k的两个子节点中较大的那个
- 如果子节点中较大的那个比k大，就交换他们的位置，否则k的位置就是正确的
代码实现
package com.study.Heap;
public class heapAPI<T extends Comparable<T>> {
// 用数组存储堆中的数据
private T[] items;
// 记录堆中的元素个数
private int N;
// 初始化数组的大小
public heapAPI(int capacity) {
// capacity+1 是因为，我们废弃掉了数组中索引为0的位置
this.items = (T[]) new Comparable[capacity + 1];
}
// 堆的元素个数
public int size() {
return N;
}
// 判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i, int j) {
return items[i].compareTo(items[j]) < 0;
}
// 交换堆中索引i和索引j处的元素
private void exchange(int i, int j) {
T temp;
temp = items[i];
items[i] = items[j];
items[j] = temp;
}
// 在堆中插入一个元素
public void insert(T t) {
// ++N 第一个元素存放在数组的1位置，0位置的索引被我们废弃了 至于为什么，我也不知道
items[++N] = t;
// 插入完，堆结构被破坏，需要使用上浮算法调整堆结构
swim(N);
}
// 使用上浮算法，使得插入的元素放在堆中的一个正确的位置
/*
上浮算法：让插入的元素和它的父节点比，比父节点大，就上移，直到比父节点小
*/
private void swim(int k) {
while (k > 1) {
// 插入的元素的值比它的父节点大，交换。
if (less(k / 2, k)) {
exchange(k / 2, k);
} else {
break;
}
k = k / 2;
}
}
// 删除堆中最大的元素，并返回这个最大元素
// 先交换要删除最大的元素和最后一个元素的位置
// 然后此时最后一个元素就是我们要删除的元素，我们直接让它指向null
// 元素减一
public T deleteMax() {
T t = items[1];
exchange(1, N);
sink(1);
items[N--] = null;
return t;
}
// 使用下沉算法，调整删除堆中的元素后，堆的结构
/*
下沉算法：
1. 循环遍历从k开始，找出k的两个子节点中较大的那个
2. 如果子节点中较大的那个比k大，就交换他们的位置，否则k的位置就是正确的
*/
private void sink(int k) {
while (2 * k <= N) {
int max;
// 找出子节点中较大的结点所在的索引
if (2 * k + 1 <= N) {
if (less(2 * k, 2 * k + 1)) {
max = 2 * k + 1;
} else {
max = 2 * k;
}
} else {
max = 2 * k;
}
// 当前结点和子结点比较
if (less(k, max)) {
exchange(k, max);
k = max;
} else {
break;
}
}
}
}
测试
package com.study.Heap;
public class heapTest {
public static void main(String[] args) {
heapAPI<String> heap = new heapAPI<>(20);
heap.insert("T");
heap.insert("S");
heap.insert("R");
heap.insert("P");
heap.insert("N");
heap.insert("O");
heap.insert("A");
heap.insert("E");
heap.insert("I");
heap.insert("H");
heap.insert("G");
System.out.println(heap.size());
String s = heap.deleteMax();
System.out.println(s);
System.out.println(heap.size());
}
}
在String s = heap.deleteMax();处打断点，debug一下，看一下删除后，堆有没有调整好
删除前的堆
删除最大元素后的堆
完美实现
堆排序
思想
将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
步骤
- 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。
- 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。
- 再给一个详解堆排序的链接
代码实现（这里没有废弃数组的0索引）
package com.study.sort.AdvanceSort;
// 堆排序
public class Heap {
public static void main(String[] args) {
int[] a = {2, 5, 2, 3, 5, 3, 10, 7, 9};
//构建大顶堆
for (int i = a.length / 2 - 1; i >= 0; i--) {
adjustHeap(a, i, a.length);
}
// 调整大顶堆，交换堆顶元素和末尾元素
for (int i = a.length - 1; i > 0; i--) {
swap(a, 0, i);//交换堆顶元素和末尾元素
adjustHeap(a, 0, i);//重新调整堆
}
// 打印排序结果
System.out.println("使用堆排序的结果：");
for (int i = 0; i < a.length - 1; i++) {
System.out.print(a[i] + ",");
}
System.out.print(a[a.length - 1]);
}
private static void adjustHeap(int[] a, int i, int length) {
int temp = a[i];
for (int j = 2 * i + 1; j < length; j = 2 * j + 1) {
if (j + 1 < length && a[j] < a[j + 1]) {
j++;
}
if (a[j] > temp) {
a[i] = a[j];
i = j;
} else {
break;
}
}
a[i] = temp;
}
private static void swap(int[] a, int m, int n) {
int temp = a[m];
a[m] = a[n];
a[n] = temp;
}
}
结果：
