排序算法小结
sort对象
- sort对象需要实现了comparable接口，comparable中包含compareTo()方法
- 内置comparable的对象有：Integer,Double,String,Date,File...
- compareTo()方法中，less返回-1，equal返回0，more返回+1
选择排序（selection sort）
- 游标从左向右移动
- 每次移动前检索游标右方所有元素的最小值，将其与游标位置元素互换
public static void sort(Comparable[] a){
int N = a.length;
for (int i = 0; i < N; i++){
int min = i;
for (int j = i+1; j < N; j++)
if (less(a[j], a[min]))
min = j;
exchange(a, i, min);
}
}
用时：\(N^2/2\)的compare与N的置换操作,对于任意情况都是如此，运行较慢
插入排序（insertion sort）
- 将游标 i 位置的元素与其左边的元素比较，如果游标元素小，则置换
public static void sort(Comparable[] a){
int N = a.length;
for (int i = 0; i < N; i++)
for (int j = i; j > 0; j--)
if (less(a[j], a[j-1]))
exch(a, j, j-1);
else break;
}
用时：
- 对于随机数组，\(N2/4\)的compare与\(N2/4\)的交换
- 对于升序（ascending）的数组，N-1次compare，0次交换
- 对于降序（descending）的数组，\(N2/2\)的compare与\(N2/2\)的交换
- 对于部分排序的数组，用时为cN
希尔排序（shellsort）
将数组A[N]变化成一个矩阵B[w][],即按w将A[N]中的元素从左至右，从上至下依次填入矩阵B中，然后对B中的每一列进行排序，通常采用插入排序。
对于w会采用一个增量序列，例如{1，4，13，40，121，364...3w[i-1]+1}，先选取小于N的最大w，然后排序，再往下选择新的w进行计算，直至w=1
3x+1序列的用时为\(O(N^{3/2})\)
归并排序（mergesort）
采用分而治之的思想，基本思路如下：
- 将序列均分为两部分
- 迭代排序每部分
- 合并两部分
private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi){
if (hi <= lo) return;
int mid = lo + (hi - lo) / 2;
sort(a, aux, lo, mid);
sort(a, aux, mid+1, hi);
merge(a, aux, lo, mid, hi);
}
用时：\(O(N*lgN)\)
实际使用更改：
- 对于长度较小的序列（如7个以下），采用插入排序
- 如果两个部分已经区分大小a[mid] < a[mid+1]，则直接连接，而非merge
快速排序（quicksort）
- 重置数组（保证效率）
- 分组：选择a[j]，将小于a[j]的元素放到其左边，大于a[j]的元素放到右边
- 对左右部分递归分组
public class Quick{
private static int partition(Comparable[] a, int lo, int hi){
int i = lo, j = hi+1;
while (true)
{
while (less(a[++i], a[lo]))
if (i == hi) break;
while (less(a[lo], a[--j]))
if (j == lo) break;
if (i >= j) break;
exch(a, i, j);
}
exch(a, lo, j);
return j;
}
public static void sort(Comparable[] a) {
StdRandom.shuffle(a);
sort(a, 0, a.length - 1);
}
private static void sort(Comparable[] a, int lo, int hi){
if (hi <= lo) return;
int j = partition(a, lo, hi);
sort(a, lo, j-1);
sort(a, j+1, hi);
}
}
用时：一般情况下快速排序比归并排序更快，但在不利情况下（选择最小或最大元素），快速排序用时为\(O(N^2)\)
快速排序是不稳定排序，归并排序是稳定排序，java中对于Object采用归并排序，在注重效率时采用快速排序
快速排序在实际操作中采用如下方式加快速度：
- 对分隔得小的序列采用插入排序
- 通过样本来获取median元素
快速排序对于重复元素值是敏感的，当重复元素过多是上述排序过程近乎二次方的用时，而归并排序相对不敏感。
处理重复元素的方法是采用3分法（3-way partitioning），即选取元素a[j]后，将数组分为小于、等于、大于a[j]的3部分，3分法的用时大大缩小，比归并排序小许多
排序方法总结
| - | stable? | worst | average | best | remarks |
|---|---|---|---|---|---|
| selection | - | \(N^2/2\) | \(N^2/2\) | \(N^2/2\) | N exchanges |
| insertion | ✔ | \(N^2/2\) | \(N^2/4\) | N | use for small N or partially ordered |
| shell | - | ? | ? | N | tight code, subquadratic |
| merge | ✔ | \(N*lg(N)\) | \(N*lg(N)\) | \(N*lg(N)\) | guarantee, stable |
| quick | - | \(N^2/2\) | \(2N*ln(N)\) | \(N*lg(N)\) | \(N*lg(N)\) probabilistic guarantee fastest in practice |
| 3-way quick | ✔ | \(N^2/2\) | \(2N*ln(N)\) | N | holy sorting grail |
应用
数组重置shuffle
- 给数组每个元素分配对应的随机数，对随机数进行排序并交换数组元素，达到重置效果
- knuth shuffle，取得0到N的两个随机数i,j，交换A[i]与A[j]
选择selection
选择排第k的元素。
采用类快速排序的方式，随机选取元素进行分组，如果左边元素为k-1，则直接返回所选元素，如果左边元素小于k-1，则说明所选元素在右边，在右边继续重复选择；否则在左边重复选择过程。
public static Comparable select(Comparable[] a, int k){
StdRandom.shuffle(a);
int lo = 0, hi = a.length - 1;
while (hi > lo){
int j = partition(a, lo, hi);
if (j < k) lo = j + 1;
else if (j > k) hi = j - 1;
else return a[k];
}
return a[k];
}
凸包（convex hull）
在一个实数向量空间V中，对于给定集合X，所有包含X的凸集的交集S被称为X的凸包。
算法：
- 选择X集合中y最小的点作为元点p
- 对其它点按照到p的角坐标\(\alpha\)进行排序
- 按序号依次将点放入凸包S中，如果新点与前两点是逆时针关系，则将该点拿出S
顺势正判别可以采用计算三角形面积的方式（向量法）
目前以有的排序算法有数百个，此处选择用得最多的几个
参考Princeton University Algorithm I
