排序算法小结
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