1.插入排序
//第一个默认有序
for(int i = 1; i < a.length; i++){
//从后往前
for(int j = i-1; j >= 0; j--){
if(a[j]>a[i]){
exch(a, i, j);
i--;
}
}
}
2.选择排序
for (int i = 0; i < a.length; i++){
int min = i;
//剩下的里面找最小的
for (int j = i + 1; j < N; j++)
if (a[j]<a[min])
min = j;
//放前面
exch(a, i, min);
}
3.冒泡排序
//每次确定一个最大的,直到倒数第二小的
for(int i = a.length-1; i > 0; i--){
for(int j = 0; j < i; j++){
if(a[j] > a[j+1])
exch(a, j, j+1);
}
}
插入排序就是打牌的时候理牌的习惯,选择排序思想最白痴,每次找个最小的,冒泡排序实现过程像插入排序,因为exch,从外部看更像选择,每次确定一个最大的。
4.希尔排序
希尔排序就是插入排序的改进版,先把数组按间隔分,然后用插入排序,在减小间隔继续插入排序直到间隔为1。
5.归并排序
public static Comparable[] aux;
public static void sort(Comparable[] a){
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}
public static void sort(Comparable[] a, int l, int h){
if (h <= l)
return;
int m = l + (h - l)/2;
sort(a, l, m);
sort(a, m+1, h);
merge(a, l, m, h);
}
public static void merge(Comparable[] a, int l, int m, int h){
int i = l;
int j = m + 1;
for (int k = l; k < a.length; k++)
aux[k] = a[k];
for (int k = l; k <= h; k++){
if (i > m)
a[k] = aux[j++];
else if (j > h)
a[k] = aux[i++];
else if (less(aux[i], aux[j]))
a[k] = aux[i++];
else
a[k] = aux[j++];
}
}
6.快速排序
public static void sort(Comparable[] a){ //此处应该有打乱 sort(a, 0, a.length -1); } private static void sort(Comparable[] a, int l, int h){ if (h <= l) return; int j = partition(a, l, h); sort(a, l, j-1); sort(a, j+1, h); } private static int partition(Comparable[] a, int l, int h){ int i = l, j = h + 1; Comparable v = a[l]; while(true){ while (less(a[++i], v)) if (i == h) break; while (less(v, a[--j])) if (j == l) break; if (i >= j) break; exch(a, i, j); } exch(a, l, j); return j; }public static void sort(Comparable[] a){ aux = new Comparable[a.length]; sort(a, 0, a.length - 1); }