《算法导论》Chapter6 堆

先介绍 堆的几个基本性质：

MAX-HEAPIFY过程，时间复杂度为O(lgn)。他是维护最大堆性质的关键；

BUILD-MAX-HEAP过程，具有线性时间复杂度，功能是从无序的输入数据数组中构造一个最大堆；

HEAPSORT过程，时间复杂度为O(nlgn)，其功能是对一个数组进行原址排序；

MAX-HEAP-INSERT,HEAP-EXTRACT-MAX,HEAP-INCREASE-KEY,HEAP-MAXIMUM过程时间复杂度为O(lgn),功能是利用堆实现一个优先队列。

6.1-1 高度为h的堆中，元素的个数范围为：2.^(h-1) <= n(h) <=2.^h-1。

建堆：对于一个n个数据的数组A，其中A(n/2+1, ..., n)（如n=15，则从n=8-15）中的元素都是树的叶子；建堆过程就是对A(n/2+1, ..., n)中的每个元素（叶节点），逆序调用一次MAX-HEAPIFY（最大值从下往上不断跑到根节点），建的堆是个最大堆。时间复杂度为O(n)；

堆排序算法：

特点：堆排序是一种选择排序算法，与关键字的初始排列次序无关，即就是在最好，最坏，一般的情况下排序时间复杂度不变。对包含n个数的输入数组，平均时间为O（nlgn），最坏情况（已经排好序）也是是O（nlgn），最好情况（完全无序）也是O（nlgn）。

下面是堆排序算法的代码实现：

        // 堆排序算法，结合下面两个算法的时间复杂度分析，可以看出堆排序算法时间复杂度为O(nlogn)
	public void HeapSort(int[] a) {
		BuildMaxHeap(a);
		for (int i = a.length - 1; i >= 1; i--) {
			swap(a, 0, i);
			MaxHeapify(a, 0, i);
		}
	}

	// 交换数组中的元素
	public void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

	// 建（最大）堆,时间复杂度为O(nlogn)，该方法调用了n次MaxHeapify；
	public void BuildMaxHeap(int[] a) {
		for (int i = a.length / 2 - 1; i >= 0; i--) {
			MaxHeapify(a, i, a.length);
		}
	}

	// 维护最大堆性质,该方法时间复杂度为O(logn),
	// 设堆的高度为h，则时间复杂度为O(h);
	// 此处，增加一个参数max，是为了适应在HeapSort方法中的对大小的变化（逐渐减小）。
	public void MaxHeapify(int[] a, int i, int max) {
		int l = 2 * i + 1; // 节点i左侧子节点
		int r = l + 1; // 节点i右侧子节点
		int largest = l; // 最大值下标
		if (l < max && a[l] > a[i]) {
			largest = l;
		} else {
			largest = i;
		}
		if (r < max && a[r] > a[largest]) {
			largest = r;
		}
		if (largest != i) {
			swap(a, largest, i);
			MaxHeapify(a, largest, max);
		}
	}

逻辑就是：先把数组构建成最大堆，由于最大堆的性质，数组第一个元素肯定是最大的，就把最大的元素a[1]和a[n]互换。之后把数组长度减1，对n-1个数组元素重新检查最大堆性质，把最大的元素重新放大a[1]位置，再次把a[1]和a[n-1]互换，这样依次循环，就把所有元素按照从小到大的顺序排列了。如果需要从大到小，可以构建最小堆，过程类似。上述代码每一个重点都有相应的注释，可以轻易看懂。

堆的一个应用：优先队列（最大优先队列和最小优先队列）

优先队列是一种用来维护由一组元素构成的集合S的数据结构，其中的每一原色都有一个相关的值，称为关键字(key)。一个最大优先队列支持以下操作：

INSERT(S,x)：把元素插入到集合S中；

MAXIMUM(S)：返回S中具有最大关键字的元素；

EXTRACT-MAX(S)：去掉并返回S中的具有最大关键字的元素；

INCREASE-KEY(S,x,k)：将元素x的关键字值增加到k；

最大优先队列有很多应用，其中一个就是在共享计算机系统中的作业调度。

最小优先队列可被应用与基于事件驱动的模拟器；

        //MAXIMUM函数，返回堆最大值
	public int MaxiMum(int[] a){
		return a[0];
	}
	//抽取出队中最大的键值，之后继续维护为最大对序列
	public int ExtractMax(int[] a){
		int max = a[0];
	    a[0] = a[a.length - 1];
	    int[] newA = new int[a.length - 1];
	    System.arraycopy(a, 0, newA, 0, newA.length);
	    MaxHeapify(newA, 0, newA.length);
	    return max;
	}

heapIncreaseKey(i, key)会增大下标为i的元素为key。首先将a[i]的值更新为key，因为增大的a[i]关键字可能会违背最大堆的性质，因此我们需要对a[i]进行逐级上升。即将当前元素逐级与父节点比较，如果大于父节点，则与父节点进行交换，一直到当前元素小于父节点为止：

public void heapIncreaseKey(int i, int key) {
    if (key > a[i]) {
        a[i] = key;
        while (i > 0 && a[parent(i)] < a[i]) {  //逐级上升
            swap(a, parent(i), i);
            i = parent(i);
        }
    } else {
        throw new IllegalArgumentException("key is too small");
    }
}

private int parent(int i) {
    return (i + 1) / 2 - 1;
}

maxHeapInsert(key)十分简单，因为它等价于数组长度增加一，然后最后一个元素设置为－∞，然后把它增大为key的操作：

public void maxHeapInsert(int key) {
    int[] newA = new int[a.length + 1];
    System.arraycopy(a, 0, newA, 0, a.length);
    newA[newA.length - 1] = Integer.MIN_VALUE;
    this.a = newA;
    heapIncreaseKey(a.length - 1, key);
}

在一个包含n个元素的堆中，所有优先队列的操作都可以在O(logn)时间内完成。

本文后半部分参考了该博文：

https://lufficc.com/blog/heap-sort-and-max-priority-queue