1. 归并排序
基本思想:利用分治法,将局部数组分割成两个局部数组,再对两局部数组执行归并排序,最后通过归并方法将两个已排序的局部数组整合成一个数组。
伪代码如下:
merge(A, left, mid, right)
n1 = mid -left
n2 = right -mid
// 生成L[0 ... n1], R[0 ... n2]
for i = 0 to n1-1
L[i] = A[left + i]
for i = 0 to n2-1
R[i] = A[mid+i]
L[n1] = INF //一个足够大的值
R[n2] = INF
i, j = 0
for k = left to right -1
if L[i] <= R[j]
A[k] = L[i]
i++
else
A[k] = R[j]
j++
MergeSort(A, left, right)
if left + 1 < right
mid = (left+right)/2
MergeSort(A, left, mid) //利用递归方式容易导致递归深度过深,使得栈溢出
MergeSort(A, mid, right)
merge(A, left, mid, right)
2. 快速排序
基本思想:先可任意一个元素作为分割点,将数组中大于该分割点的元素放置在其右边,小于该分割点的元素置于其左边。然后再对分割成的两部分执行以上同样的操作,直至完成排序。
伪代码:
quickSort(A, p, r)
if p < r
q = partition(A, p, r)
quickSort(A, p, q-1)
quickSort(A, q+1, r)
int partition(int A[], int n, int p, int r) {
int i, j;
int t, x;
x = A[r];
i = p - 1;
for (j = p; j < r; j++) {
if (A[j].value <= x.value) {
i++;
t = A[i]; A[i] = A[j]; A[j] = t;
}
}
t = A[i+1]; A[i+1] = A[r]; A[r] = t;
return i+1;
}
3. 计数排序
思想:属于稳定排序算法,能在线性时间(O(n+k))内对包含n个元素的数组排序,其中数组元素均大于等于0且小于等于k。
伪代码:
CountSort(A, B, k) //A为输入数组,B为输出数组
for i = 0 to k
C[i] = 0
// 在C[i] 中记录i的出现次数
for j = 1 to n
C[A[j]]++
// 在C[i]中记录小于等于i的元素的出现次数
for i = 1 to k
C[i] = C[i] + C[i-1]
for j = n to 1
B[C[A[j]]] = A[j]
C[A[j]]--