算法（伪代码）

快速排序

QuickSort(A[l,r])

if l

s = FindAxis(A[l,r])

Quicksort(A[l, s-1])

Quicksort(A[s+1, r])

FindAxis(A[l,r])
p = A[l]
i=l j=r+1
repeat

repeat ++i until A[i]>=p
repeat --j until A[j]<=p

swap(A[i], A[j])

until i>=j
swap(A[i], A[j])
swap(A[l], A[j])

return j

对应代码

int FindAxis(std::vector &data, int b, int e)
{

int ref = data[b];

int i = b+1;

int j = e;

while(1)

{

while(i<=e && data[i]

i++;

}

while(data[j] > ref) {

j--;

}

if(i

swap(data, i, j);

i++;

j--;

} else {

break;

}

}

swap(data, b, j);

return j;

}


void QuickSort(std::vector &data, int b, int e)
{

if(b>=e)  return;

int axis = FindAxis(data, b, e);

QuickSort(data, b, axis-1);

QuickSort(data, axis+1, e);

}

三平均分区法

找出最左，中间，最右的中间值作为中轴

（1）减少最坏情况

（2）不需要设哨点

堆两个条件：

1 完全二叉树

2 每个节点的键大于等于它的子键

堆排序

HeapSort(data[1,n])
	BuildHeap(data[1,n])
	for(i=n; i>1; i--)
		swap(data[1], data[i])
		AjustHeap(data[1, i-1], 1)

BuildHeap(data[1, n])
	for(i=n/2; i>=1; i--)
		AdjustHeap(data[1, n], i)

AjustHeap(data[1, n], i)
	v = data[i]
	k = i
	heap = false;
	while(not heap && 2*k<=n) {
		j = 2*k
		if(j>n)
			if(data[j] data[j])
			heap = true;
		else
			data[k] = data[j]
			k = j
	}
	data[k] = v