标签:效果 过多 递归 date 参考 while 思路 practice course
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的置换操作,对于任意情况都是如此,运行较慢
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;
}
用时:
将数组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})\)
采用分而治之的思想,基本思路如下:
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)\)
实际使用更改:
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采用归并排序,在注重效率时采用快速排序
快速排序在实际操作中采用如下方式加快速度:
快速排序对于重复元素值是敏感的,当重复元素过多是上述排序过程近乎二次方的用时,而归并排序相对不敏感。
处理重复元素的方法是采用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
选择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的凸包。
算法:
按序号依次将点放入凸包S中,如果新点与前两点是逆时针关系,则将该点拿出S
顺势正判别可以采用计算三角形面积的方式(向量法)
目前以有的排序算法有数百个,此处选择用得最多的几个
参考Princeton University Algorithm I
标签:效果 过多 递归 date 参考 while 思路 practice course
原文地址:https://www.cnblogs.com/fugeny/p/9563408.html