算法导论 第六章 堆排序
算法导论第六章 堆排序
一 概念
1.（二叉）堆是数据结构的一种数组对象（堆是数组而不是一般的树）
2.但它可以视为一棵完全二叉树，二叉树的层次遍历对就数组元素的顺序对应，树根对应A[1],
对于第i个元素，有以下主要关系：
PARENT(i) return i/2 // its parent
LEFT(i) return 2*i // its left child
RIGHT(i) return 2*i+1
3.最大堆（根结点最大）：
A[PARENT(i)] >= A[i]; // 父结点不小于子结点
最小堆：
A[PARENT(i)] <= A[i]; // 父结点不大于子结点
4.堆的高度：
从本结点到叶子结点的最长简单下降路径上边的数目，定义堆的高度为树根的高度，叶子结点高度为0，对于n个结点的堆，高度为 floor（lgn）即lgn向下取整数
二。堆的数据结构
1. A[N]: 堆数组
length[A]: 数组中元素的个数
heap-size[A]: 存放在A中的堆的元素个数
2. 操作：
（1）MAX—HEAPIFY（A，i）过程O(lgn)，保持最大堆性质的关键
（2）BUILD—MAX—HEAP 过程O(n)，构造最大堆
（3）HEAPSORT 运行时间O(n*lgn),对数组进行排序
（4）堆运用于优先级队列：
MAX-HEAP-INSERT(A, val) // insert a element to A
HEAP-EXTRACT-MAX(A) // remove and return the max element of A
HEAP-INCREASE-KEY(A, i, ival) // increase the ith element's val to ival
MAXIMUM(A) // return the element which has the greatest val
三，程序实现
#include <stdio.h>
#include <stdlib.h>
#define PARENT(i) (i) >> 1 // parent of i
#define LEFT(i) (i) << 1 // left child of i
#define RIGHT(i) ((i)<<1) + 1 // right child of i
#define MINVAL (signed)(1 << 31)
static int heap_size = 0;
static int length = 0;
/*
* 以LEFT(i)和RIGHT(i)为根的两棵二叉树都是已建好的最大堆
* 但A[i]可能小于其孩子，此时对其"下降"调整使满足最大堆性质
* recusion Version
*/
void max_heapify(int *heap, int i)
{
int l, r, largest;
l = LEFT(i);
r = RIGHT(i);
if (l <= heap_size && heap[l] > heap[i])
largest = l;
else
largest = i;
if (r <= heap_size && heap[r] > heap[largest])
largest = r;
if (largest != i) { // need to be adjusted
int t = heap[i];
heap[i] = heap[largest];
heap[largest] = t;
max_heapify(heap, largest);
}
}
/* not recursion version */
void max_heapify02(int *heap, int i)
{
int l, r, largest;
int t;
while (1) {
l = LEFT(i);
r = RIGHT(i);
if (l <= heap_size && heap[l] > heap[i])
largest = l;
else
largest = i;
if (r <= heap_size && heap[r] > heap[largest])
largest = r;
if (largest != i) {
t = heap[largest];
heap[largest] = heap[i];
heap[i] = t;
i = largest;
} else
break;
}
}
void build_max_heap(int *heap)
{
int i;
for (i = heap_size / 2; i >= 1; i--)
max_heapify(heap, i);
}
void heapsort(int *heap)
{
int i, t;
build_max_heap(heap);
for (i = length; i >= 2; i--) {
t = heap[i];
heap[i] = heap[1];
heap[1] = t;
heap_size--;
max_heapify(heap, 1);
}
heap_size = length;
}
int heap_maximum(int *heap)
{
return heap[1];
}
int heap_extract_max(int *heap)
{
int max;
if (heap_size < 1) {
fprintf(stderr, "heap underflow\n");
exit(0);
}
max = heap[1];
heap[1] = heap[heap_size];
heap_size--;
max_heapify(heap, 1);
return max;
}
/* the key must not less then the original val heap[i] */
void heap_increase_key(int *heap, int i, int key)
{
int t;
if (i < 1 || i > heap_size) {
fprintf(stderr, "invalid position of %d\n", i);
exit(-1);
}
if (key < heap[i]) {
fprintf(stderr, "new key is smaller than current key\n");
exit(-1);
}
while (i > 1 && key > heap[PARENT(i)]) {
heap[i] = heap[PARENT(i)];
i = PARENT(i);
}
heap[i] = key;
}
void max_heap_insert(int *heap, int key)
{
heap_size++;
heap[heap_size] = MINVAL;
heap_increase_key(heap, heap_size, key);
}
void print_heap(int *heap)
{
int i;
for (i = 1; i <= heap_size; i++)
printf("%3d ", heap[i]);
printf("\n"); } int main() { //int arr[] = { 0, 10, 9, 2, 100, 300, 56, 67, 3, 2, 2, 20, 10 }; int arr[] = { 0, 100, 2, 20, 10 }; int i, x; length = sizeof(arr) / sizeof(*arr) - 1; heap_size = length; printf("original array:\n"); print_heap(arr); build_max_heap(arr); printf("max heap:\n"); print_heap(arr); /* printf("after sorted:\n"); heapsort(arr); print_heap(arr); */ printf("after extract max:\n"); heap_extract_max(arr); print_heap(arr); x = 33; printf("insert %d to the heap:\n", x); max_heap_insert(arr, x); print_heap(arr); return 0; }
四，部分习题解答：
6.1-1: 2^(h+1) 2^h
6.1-2: 含n个元素的堆的高度为 lgn 取下整数
1+2+4+...+2^(h-1) < n <= 1+2+4+..2^h
(1-2^h)/(1-2) < n <= (1-2^(h+1))/(1-2)
2^h-1 < n <= 2^(h+1)-1 --> 2^h <= n < 2^(h+1)
--> h <= lgn < h+1 --> h = floor(lgn)
6.1-3: 由堆的定义可得
6.1-4：叶子结点
6.1-5: No
6.1-6：no
6.1-7: 最后一个结点n的父结点为n／2，其父结点之后为叶子结点
6.2-2：minmum heap
MIN-HEAPIFY(A, i)
l = LEFT(i)
r = RIGHT(i)
if l <= heap-size[A] and A[l] < A[i]
smallest = l;
else
smallest = i;
if r <= heap-size[A] and A[r] < A[smallest]
smallest = r
if smallest != i
A[i] <-> A[smallest]
MIN-HEAPIFY(A, smallest)
6.2-3:
程序执行一次测试立刻退出，不改变堆
6.2-4：
一次测试后立刻退出，堆不变
6.2-5：
见上面代码 not recursion ersion
6.2-6：
一直不知道证明？？？
6.3-2：
从下至上建堆，可以利用建好的堆调用MAX-HEAPIFY
6.3-3：
n <= 2^(h+1)
第0层最多 2^h
第1层最多 2^(h-1)
...
第h层（根层） 1 >= n / (2^(h+1))
6.5-7:
因为insert程序调用HEAP—INCREASE—KEY（），而increase函数要求插入的key大于原来的值，所以先把原来的值设为最小值。
6.5-8:
见堆排序k路合并
思考题
6-1: 用插入法建堆
BUILD-MAX-HEAP02(A)
heap-size[A] = 1
for i = 2 to length[A]
MAX-HEAP-INSERT(A, A[i])
MAX-HEAP-INSERT(A, A[i])
同上
a) 不一样 A ＝ { 1, 2, 3 }
6－2： d叉堆的分析
d叉堆与二叉堆类似，只是其中每一个非叶子结点有d个子女
PARENT(i) = (i-2)/d + 1
LEFTMOST(i) = d*(i-1) + 2
//RIGHTMOST(i) = d*i+1
CHILD(i, j) = d * (i-1) + j + 1
a) 根结点为A[1],根结点的孩子为A[2],A[3]...A[d+1]
b) lgn / lgd
c) O(lgn/lgd * d)
EXTRACT-MAX(A)
max = A[1]
A[1] = A[heap-size[A]]
heap-size[A] = heap-size[A]-1
MAX-HEAPIFY(A, 1)
其中：
MAX-HEAPIFY(A, i)
l = LEFTMOST(i)
r = RIGHTMOST(i)
largest = i;
while (l <= r && l <= heap-size[A])
if (A[l] > A[largest])
largest = l
l <- l+1
if largest != i
A[i] <-> A[largest]
MAX-HEAPIFY(A, largest)
d) lgn / lgd
MAX-HEAP-INSERT(A, key)
heap-size[A] <- heap-size[A] + 1
A[heap-size[A]] <- 无穷小
HEAP-INCREASE-KEY(A, heap-size[A], key)
e) lgn / lg d
HEAP-INCREASE-KEY(A, i, key)
//if key < A[i]
// then error "new key is samller than current key"
// A[i] <- key
//while i > 1 and A[PARENT(i)] < A[i]
// do exchange A[i] <-> A[PARENT(i)]
// i <- PARENT(i)
key <- MAX(A[i], key)
while i > 1 and A[PARENT(i)] < key
do A[i] <- A[PARENT(i)]
i = PARENT(i)
A[i] = key
