一、堆的定义
堆通常可以被看做是一棵完全二叉树的数组对象。
特性：
- 它是完全二叉树。
除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的，那么要求左满右不满。 - 它通常用数组来实现。
具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子结点则分别在位置4,5,6和7，以此类推。如果一个结点的位置为k，则它的父结点的位置为[k/2],而它的两个子结点的位置则分别为2k和2k+1。这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动：从a[k]向上一层，就令k等于k/2,向下一层就令k等于2k或2k+1。 - 每个结点都大于等于它的两个子结点。
这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。
二、API设计
| 类名 | Heap<T> |
|---|---|
| 构造方法 | Heap(int capacity)：创建容量为capacity的Heap对象 |
| 成员方法 | 1.private boolean less(int i,int j)：判断堆中索引i处的元素是否小于索引j处的元素 2.private void exch(int i,int j):交换堆中i索引和j索引处的值 3.public T delMax():删除堆中最大的元素,并返回这个最大元素 4.public void insert(T t)：往堆中插入一个元素 5.private void swim(int k):使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置 6.private void sink(int k):使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置 |
| 成员方法 | 1.private T[] imtes : 用来存储元素的数组 2.private int N：记录堆中元素的个数 |
三、代码实现
3.0 属性+构造器
public class Heap<T extends Comparable<T>> {
// 数组用来存元素
private T[] items;
// 用来记录堆中元素的个数
private int N;
// 创建容量为capacity的Heap对象
public Heap(int capacity) {
items = (T[]) new Comparable[capacity+1]; //堆会废弃0索引处的值
N = 0;
}
}
3.1 插入一个元素
// 插入：注意因为堆中元素有顺序，而且是数组实现的只能从索引0依次向后存放数据
// 所以每次插入元素后都会使堆中元素的顺序变乱，需要重排序
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;
}
}
// 判断堆中索引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 tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
3.2 删除最大元素
// 删除堆中最大的元素，并返回这个最大元素
public T delMax(){
T max = items[1];
// 交换索引1处和索引N处的值
exch(1,N);
// 删除最后位置上的元素
items[N] = null;
N--;
sink(1);
return max;
}
// 使用下沉算法，使索引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)){
break;
}
// 当前节点小，则交换
exch(k,max);
k = max;
}
}
3.3 堆排序
public class HeapSort {
// 堆排序 -- 对source数组中的数据从小到大排序
public static void sort(Comparable[] source) {
// 创建一个比原数组大1的数组
Comparable[] heap = new Comparable[source.length + 1];
// 根据原数组构造出堆
createHeap(source, heap);
// 得到堆顶元素，这个值就是最大值
// 减缓对丁元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置
// 对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶
// 重复2-4这个步骤，直到堆中剩一个元素为止
// 堆排序
int N = heap.length-1;
while (N!=1){
// 3.2交换heap中索引1处的元素和N处的元素
exch(heap, 1, N);
N--;
// 3.3对索引1处的元素在0~N范围内做下沉操作
sink(heap, 1, N);
}
// 4.heap中的数据已经有序，拷贝到source中
System.arraycopy(heap,1,source,0,source.length);
}
private static void createHeap(Comparable[] source, Comparable[] heap) {
System.arraycopy(source, 0, heap, 1, source.length);
for (int i = (heap.length - 1) / 2; i > 0; i--) {
sink(heap, i, heap.length - 1);
}
}
// 在head堆中，对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;
}
}
//判断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 tmp = heap[i];
heap[i] = heap[j];
heap[j] = tmp;
}
}