排序算法Java

排序

排序算法类的模板

public class Example {
    public static void sort(Comparable[] a){

    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for (int i=0;i<a.length;i++)
        {
            StdOut.print(a[i]+" ");
        }
        StdOut.println();
    }
    public static boolean isSorted(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){
        //从标准输入读取字符串，将他们排序并输出
        String[] a=In.readStrings();
        sort(a);
        assert isSorted(a);
        show(a);
    }
}

选择排序

最简单的排序算法：首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置。再次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。

特点：

1. 运行时间和输入无关。
2. 数据移动最少。

public class Selection {
    public static void sort(Comparable[] a){
        //将a[]按升序排列
        int N=a.length;
        for(int i=0;i<N;i++){
            //将a[i]和a[i+1....N]中最小的元素交换
            int min=i;
            for(int j=i+1;j<N;j++){
                if (less(a[j],a[min]))  min=j;
            }
            exch(a,i,min);
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for (int i=0;i<a.length;i++)
        {
            StdOut.print(a[i]+" ");
        }
        StdOut.println();
    }
    public static boolean isSorted(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){
        //从标准输入读取字符串，将他们排序并输出
        String[] a=In.readStrings();
        sort(a);
        assert isSorted(a);
        show(a);
    }
}

插入排序

与选择排序一样，当前索引左边的所有元素都是有序的，但是它们的最终位置还不确定，为了给更小的元素腾出空间，它们可能会被移动。当索引到达数组的右端时，数组排序就完成了。

和选择排序不同的是，插入排序所需要的时间取决于输入中元素的初始顺序。

public class Insertion {
    public static void sort(Comparable[] a){
        //将a[]按升序排列
        int N=a.length;
        for (int i=1;i<N;i++){
            for(int j=i;j>0&&less(a[j],a[j-1]);j--)
                exch(a,j,j-1);
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for (int i=0;i<a.length;i++)
        {
            StdOut.print(a[i]+" ");
        }
        StdOut.println();
    }
    public static boolean isSorted(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){
        //从标准输入读取字符串，将他们排序并输出
        String[] a=In.readStrings();
        sort(a);
        assert isSorted(a);
        show(a);
    }
}

希尔排序

希尔排序的思想是使数组中任意间隔为h的元素都有序。这样的数组被称为h有序数组。换句话说，一个h有序数组就是h个互相独立的有序数组编织在一起组成的一个数组。

public class Shell {
    public static void sort(Comparable[] a){
        //将a[]按升序排列
        int N=a.length;
        int h=1;
        while(h<N/3) h=3*h+1;
        while(h>=1){
            //将数组变为h有序
            for(int i=h;i<N;i++){
                for (int j=i;j>=h&&less(a[j],a[j-h]);j-=h)
                    exch(a,j,j-h);
            }
            h=h/3;
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }
    private static void show(Comparable[] a){
        for (int i=0;i<a.length;i++)
        {
            StdOut.print(a[i]+" ");
        }
        StdOut.println();
    }
    public static boolean isSorted(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){
        //从标准输入读取字符串，将他们排序并输出
        String[] a=In.readStrings();
        sort(a);
        assert isSorted(a);
        show(a);
    }
}