算法--排序（选择、插入、希尔、归并）

选择排序

public class Selection {
// 排序
public static void sort(Comparable[] a) {
//将数组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;//交换索引，使min指向最小的元素下标
}
}
exch(a, i, min);//交换元素位置
}
}
// 元素之间进行比较
public static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0; // 如果v<w则为true
}
// 交换元素位置
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
// 单行中打印数组
public static void show(Comparable a[]) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}
// 测试数组是否有序
public static boolean isShorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
Integer a[]={2,3,4,1,55,6,3,6,7};
sort(a);
System.out.println(isShorted(a));
show(a);
}

}

插入排序

插入排序对部分有序的数组很有效，也适合小规模数组。

改进：在内循环中将较大的元素都向右移动而不总是交换两个元素（这样访问数组的次数就能减半）。

public class Insertion {
// 排序
public static void sort(Comparable[] a) {
// 将a[]按升序排列
int N = a.length;
for (int i = 1; i < N; i++) {
/**
* 将a[i]插入到a[i-1] a[i-2] a[i-3]之中
* 如果a[j]<a[j-1],则交换位置，此时a[j]中的元素给了a[j-1]，再将a[j-1]与a[j-2]比较，如此重复，
* 直到最小元素到达最左边
*/
for (int j = i; j > 0 && less(a[j], a[j - 1]); j--) {
exch(a, j, j - 1);
}
}
}
// 元素之间进行比较
public static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0; // 如果v<w则为true
}
// 交换元素位置
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
// 单行中打印数组
public static void show(Comparable a[]) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}
// 测试数组是否有序
public static boolean isShorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
Integer a[] = { 2, 3, 4, 1, 55, 6, 3, 6, 7, 8 };
sort(a);
System.out.println(isShorted(a));
show(a);
}

}

希尔排序

public class Shell {
// 排序
public static void sort(Comparable[] a) {
int N = a.length;
int h = 1;
while (h < N / 3) {
h = 3 * h + 1;
}
while (h >= 1) {
for (int i = h; i < N; i++) {
// 将a[i]插入到a[i-h],a[i-2*h],....中
for (int j = i; j - h >= 0 && less(a[j], a[j - h]); j -= h) {
exch(a, j, j - h);
}
}
h = h / 3;// 缩小h的范围
}
}
// 元素之间进行比较
public static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0; // 如果v<w则为true
}
// 交换元素位置
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
// 单行中打印数组
public static void show(Comparable a[]) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}
// 测试数组是否有序
public static boolean isShorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
Integer a[] = { 2, 3, 4, 1, 55, 6, 3, 6, 7 };
sort(a);
System.out.println(isShorted(a));
show(a);
}
}

归并排序

原地归并

自顶向下的归并排序

public class Merge {
private static Comparable aux[];
public static void sort(Comparable a[]) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}
private static void sort(Comparable a[], int firstIndex, int lastIndex) {
if (firstIndex>=lastIndex) {
return;
}
int midIndex=firstIndex+(lastIndex-firstIndex)/2;
sort(a,firstIndex,midIndex);//左边排序
sort(a, midIndex+1, lastIndex);//右边排序
merge(a, firstIndex, midIndex, lastIndex);//归并结果
}
private static void merge(Comparable a[], int firstIndex, int midIndex, int lastIndex) {
int i = firstIndex;
int j = midIndex + 1;
// 将数组a里的元素复制到aux中
for (int k = firstIndex; k <= lastIndex; k++) {
aux[k] = a[k];
}
for (int k = firstIndex; k <= lastIndex; k++) {
if        (i > midIndex)                               a[k] = aux[j++];// 左边取完取右边
else if (j > lastIndex)                               a[k] = aux[i++];// 右边取完取左边
        else if (aux[j].compareTo(aux[i]) < 0)   a[k] = aux[j++];
else                                                           a[k] = aux[i++];
}
}
public static void show(Comparable a[]) {
int N = a.length;
for (int i = 0; i < N; i++) {
System.out.print(a[i] + " ");
}
}
public static void main(String[] args) {
String a[] = { "E", "E", "G", "M", "R", "A", "E", "C", "R", "T" };
sort(a);
show(a);
}

}

归并排序所需的时间和NlgN成正比。

主要缺点是辅助数组所使用的额外空间和N的大小成正比。

自底向上的归并排序

public class MergeBU {
private static Comparable[] aux;// 辅助数组
public static void sort(Comparable[] a) {
int N = a.length;
aux = new Comparable[N];
for (int sz = 1; sz < N; sz += sz) {
for (int firstIndex = 0; firstIndex < N - sz; firstIndex += sz + sz) {
                            merge(a, firstIndex, firstIndex+sz-1,Math.min(firstIndex+sz+sz-1,N-1) );
}
}
}
private static void merge(Comparable[] a, int firstIndex, int midIndex, int lastIndex) {
int i = firstIndex;
int j = midIndex + 1;
System.arraycopy(a, firstIndex, aux, firstIndex, lastIndex-firstIndex+1);// 数组复制
for (int k = firstIndex; k <= lastIndex; k++) {
if        (i > midIndex)                               a[k] = aux[j++];
else if (j > lastIndex)                               a[k] = aux[i++];
else if (aux[j].compareTo(aux[i]) < 0)   a[k] = aux[j++];
else                                                           a[k] = aux[i++];
}
}
public static void show(Comparable a[]) {
int N = a.length;
for (int i = 0; i < N; i++) {
System.out.print(a[i] + " ");
}
}
public static void main(String[] args) {
String a[] = { "M", "E", "R", "G", "E", "S", "O", "R", "T","E","X","A","M","P","L","E" };
sort(a);
show(a);
}
}

排序算法的复杂度