算法导论第五天学习笔记

堆排序（续）

堆排序算法

HEAPSORT(A):
	BUILD-MAX-HEAP(A)
	for i = A.length downto 2
		exchange A[1] with A[i]
		A.heap-size = A.heap-size - 1
		MAX-HEAPIFY(A, 1)

优先队列

优先队列 是一种用来维护由一组元素构成的集合S的数据结构，其中的每一个元素都有一个相关的值，称为关键字

HEAP-EXTRACT-MAX(A):
	if A.heap-size < 1
		error "heap underflow"
	max = A[1]
	A[1] = A[A.heap-size]
	A.heap-size =  A.heap-size -1
	MAX-HEAPIFY(A, 1)
	return max

HEAP-INCREASE-KEY(A, i, key):
	if key < A[i]
		error "new key is smaller than current key"
	A[i] = key
	while i > 1 and A[PARENT(i)] < A[i]
		exchange A[i] with A[PARENT(i)]
		i = PARENT(i)

快速排序

快速排序的描述

QUICKSORT(A, p, r):
	if p < r 
		q = PARTITION(A, p, r)
		QUICKSORT(A, p, q -1)
		QUICKSORT(A, q + 1, r)

PARITION(A, p, r):
	x = A[r]
	i = p-1
	for j = p to r - 1
		if A[j] <= x
			i = i + 1
			exchange A[i] with A[j]
	exchange A[i + 1] with A[r]
	return i + 1

快速排序的性能

最坏情况：O（n²）
平均：O（nlgn）

快速排序的随机化版本

主要是通过随机函数随机选取主元（进行划分的元素）

RANDOMIZED-PARTITION(A, p, r):
	i = RANDOM(p, r)
	exchange A[r] with A[i]
	return PARTITION(A, p, r)

RANDOMIZED-QUICKSORT(A, p, r):
	if p < r
		q = RANDOMIZED-PARTITION(A, p, r)
		RANDOMIZED-QUICKSORT(A, p, q - 1)
		RANDOMIZED-QUICKSORT(A, q - 1, r)

快速排序分析

略。。。

线性时间排序

排序算法的下界

1、在最坏情况下，任何比较排序算法都需要做Ω（nlgn）次比较。
2、堆排序和归并排序都是渐进最优的比较排序

计数排序

COUNTING-SORT(A, B, k):
	let C[0..k] be a new array
	for i = 0 to k
		C[i] =0
	for j = 1 to A.length
		C[A[j]] = C[A[j] + 1
	for i = 1 to k
		C[i] = C[i] + C[i -1]
	for j = A.length downto 1
		B[C[A[j]]] = A[j]
		C[A[j]] = C[A[j]] - 1

计数排序是稳定的

基数排序

RADIX-SORT(A, d):
	for i = 1 to d
		use a stable sort to sort array A on digit i

1、给定n个d位数，其中每一个数位有k个可能的取值。如果RADIX-SORT使用的稳定排序方法耗时Θ（n+k），那么它就可以在Θ（d（n+k））时间内将这些数排好序。
2、给定一个b位数和任何正整数人r <= b，如果RADIX-SORT使用的稳定排序算法对数据取值区间是0到k的输入进行排序耗时Θ（n+k），那么它就可以在Θ（(b / r)(n + $2^r$)）时间内将这些数据排好序。