java算法系列-排序

排序在工作中也是经常用到，网上也是有很多的教程，在这里就自己总结了几种排序的算法。

1. 选择排序：
   首先，找到数组中最小的那个元素，其次就是将它和数组中的第一个元素的位置交换，再次就是在剩下的元素中找到最小的元素，将它和第二个元素交换，如此重复下去一直到整个数组排序，因为它一直在不断选择剩余最小的元素，所以叫选择排序。

public class SelectionSort {

    public static boolean less(Comparable v,Comparable w){
        return v.compareTo(w) < 0;
    }

    //交换
    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++) {
            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 sort(Comparable[] array) {
        //将数组array按照升序排列
        int N = array.length;
        for (int i = 0;i<N;i++) {
            //将array[i]和array[i+1...N]中最小的元素交换
            int min = i;//最小的下标
            for (int j = i+1;j<N;j++) {
                if (less(array[j],array[min])) {
                    min = j;
                }
            }
            //交换
            exch(array,i,min);
        }
    } 
    public static void main(String[] args) {
        String[] a = {"f","a","x"};
        sort(a);
        show(a);
    }
}

上述的代码中交换的方法写在内循环的外边，每次交换就能排定一个元素，因此交换的次数是N，所以算法的时间效率取决与比较的次数。

1. 插入排序
   **我们在打牌的时候整理自己牌的时候，就是将每一张牌插入到其他已经有序的牌中的适当的位置，在计算机中我们要给插入的元素留位置，我们需要将其余的元素在插入之前都向后移动一个位置，这种算法我们叫做插入排序。
   与选择排序一样，当前索引左边的所有元素都是有序的，但是他们在排序结束之前位置是不确定的，为了给更小的元素腾出空间，它可能会被移动，等到索引到达数组最右边的时候数组就排好序了。

**

public class InsertionSort {

    public static boolean less(Comparable v,Comparable w){
        return v.compareTo(w) < 0;
    }

    //交换
    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++) {
            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 sort(Comparable[]array){
        //按照升序排列
        int N = array.length;
        for (int i = 1;i<N;i++) {
            //将array[i]插入到array[i-1],array[i-2],array[i-3]...中
            for (int j = i;j>0 && less(array[j],array[j-1]);j--) {
                exch(array,j,j-1);
            }
        }
    }

    public static void main(String[] args) {
        String[] a = {"f","a","x"};
        sort(a);
        show(a);
    }



}

3.希尔排序
希尔排序是一种基于插入排序的快速排序，希尔排序就是插入排序的优化。希尔排序的思想就是使数组中的任意间隔为h的元素都是有序的，这样的数组被称为h有序数组，一个h有序数组就是h个互相独立的有序数组组成的大数组。

public class ShellSort {

    public static boolean less(Comparable v,Comparable w){
        return v.compareTo(w) < 0;
    }

    //交换
    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++) {
            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 sort(Comparable[]array){
        //升序排列
        int N = array.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(array[j],array[j-h]);j-=h) {
                    exch(array,j,j-h);
                }
            }
            h = h/3;
        }
    }


    public static void main(String[] args) {
        String[] a = {"f","a","x"};
        sort(a);
        show(a);
    }

}