排序的算法

一、简单排序

1.2冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的比较简单的排序算法

排序原理：
1.比较相邻的元素，如果前一个元素比后一个元素大，就交这两个元素的位置。
2.对每一对相邻元素做同样的工作，从开始第一队元素到结尾的最后一对元素。最终最后位置的元素就是最大值。

//排序代码
public class Bubble {
    /*
        对数组a中的元素进行排序
     */
    public static void sort(Comparable[] a){
        for (int i = a.length - 1; i >0; i--) {
            for (int j = 0; j < i; j++) {
                if (greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }

    /*
        比较v元素是否大于w元素
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
        交换元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i , int j){
        Comparable t =a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

public class BubbleTest {
    public static void main(String[] args) {
        Integer[] a = {4,5,6,3,2,1};
        Bubble.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

时间复杂度：O（N^2）

1.2选择排序

简单直观的排序算法
排序原理：
1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引处的值为最小值，最后可以找到最小值所在的索引。
2.交换第一个索引处和最小值所在的索引。

//排序代码
public class Selection {
    /*
        对数组a中的元素进行排序
     */
    public static void sort(Comparable[] a){
        for (int i = 0; i <= a.length - 2; i++) {
            //假定本次遍历，最小值所在的索引是i
            int minIndex = i;
            for (int j = i+1; j < a.length; j++) {
                if (greater(a[minIndex],a[j])){
                    minIndex=j;
                }
            }
            //交换i索引处和minIndex索引处的值
            exch(a,i,minIndex);
        }
    }

    /*
    比较v元素是否大于w元素
 */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
        交换元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i , int j){
        Comparable t =a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

public class SelectionTest {
    public static void main(String[] args) {
        Integer[] a = {4,6,8,7,9,2,10,1};
        Selection.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

时间复杂度：O（N^2）

1.2插入排序

简单直观且稳定的排序算法
排序原理：
1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他元素向后移动一位。

public class Insertion {

    /*
        对数组a中的元素进行排序
     */
    public static void sort(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            //当前元素为a[i],依次和i前面的元素比较，倒叙遍历，找到一个小于等于a[i]的元素
            for (int j = i; j > 0; j--) {
                if (greater(a[j-1],a[j])){
                    //交换元素
                    exch(a,j-1,j);
                }else {
                    //找到了该元素，结束
                    break;
                }
            }
        }
    }


    /*
        比较v元素是否大于w元素
    */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
        交换元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i , int j){
        Comparable t =a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

public class InsertionTest {
    public static void main(String[] args) {
        Integer[] a = {4,6,8,7,9,2,10,1};
        Insertion.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

时间复杂度：O（N^2）

二、高级排序

2.1希尔排序

插入排序的一种，又称“缩小增量排序”。
1.选定一个增量h，按照增长量h作为数据分组的依据，对数据进行分组；
2.对分好组的每一组数据完成插入排序；
3.减小增长量，最小减为1，重复第二步操作。

增长量h的确定：增长量h的值每一固定的规则，采取以下规则

2.2归并排序

2.2.1递归

方法内部调用方法本身
作用：把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。
注意事项：必须要有边界条件，能够让递归结束，要不然会造成栈内存溢出

2.2.2归并排序

分治法，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列段间有序。若将两个有序表合并成一个有序表，称二路归并。
排序原理：
1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，知道拆分后的每一子组的元素个数是1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3.不断的重复步骤2，直到最终只有一个组为止。

//排序代码
public class Merge {
    private static Comparable[] assist;//归并所需要的辅助数组

    /*
        对数组a中的元素进行排序
     */
    public static void sort(Comparable[] a){
        assist = new Comparable[a.length];
        int lo = 0;
        int hi = a.length-1;
        sort(a,lo,hi);
    }

    /*
         对数组a中从lo到hi的元素进行排序
     */
    private static void sort(Comparable[] a,int lo,int hi){
        if (hi<=lo){
            return;
        }

        int mid = lo +(hi-lo)/2;

        //对lo到mid之间的元素进行排序
        sort(a,lo,mid);
        //对mid+1到hi之间的元素进行排序
        sort(a,mid+1,hi);
        //对lo到mid这组数据和mid到hi这组数据进行归并
        merge(a,lo,mid,hi);
    }

    /*
        对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
     */
    private static void merge(Comparable[] a, int lo,int mid,int hi){
        //lo到mid这组数据和mid+1到hi这组数据归并到辅助数组assist对应的索引处
        int i = lo;//定义一个指针，指向assist数据中开始填充数据的索引
        int p1= lo;//定义一个指针，指向第一组数据的第一个元素
        int p2 = mid+1;//定义一个指针，指向第二组数据的第一个元素

        //比较左边小组和右边小组中的元素大小，哪个小，就把哪个数据填充到assist数组中
        while (p1<=mid&&p2<=hi){
            if (less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else {
                assist[i++] = a[p2++];
            }
        }

        //上面的循环结束后，如果退出循环的条件是p1<mid,则证明左边小组中的数据已经归并完毕，
        // 如果退出循环的条件是p2<=hi，则证明右边小组的数据已经填充完毕；
        //所以需要把未填充完毕的数据继续填充到assist中
        while (p1<=mid){
            assist[i++] = a[p1++];
        }

        while (p2<=hi){
            assist[i++] = a[p2++];
        }

        for (int index=lo;index<=hi;index++){
            a[index] = assist[index];
        }
    }

    /*
        比较v元素是否小于w元素
    */
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }

    /*
        交换元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i , int j){
        Comparable t =a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

public class MergeTest {
    public static void main(String[] args) {
        Integer[] a = {8,4,5,7,1,3,6,2};
        Merge.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

时间复杂度：O（nlogn）

2.3快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
排序原理：
1.首先设定一个分界值，通过该分界值将数组分成左右两部分；
2.将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4.重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

public class Quick {

    //对数组内的元素进行排序
    public static void sort(Comparable[] a){
        int lo =0;
        int hi = a.length-1;
        sort(a,lo,hi);
    }


    //对数组a中从索引lo到索引hi之间的元素进行排序
    public static void sort(Comparable[] a,int lo,int hi){
        //安全性校验
        if (hi<=lo){
            return;
        }

        //需要对数组中lo的索引到hi索引处的元素进行分组（左子组和右子组）；
        int partition = partiton(a,lo,hi);

        //让左子组有序
        sort(a,lo,partition-1);

        //让右子组有序
        sort(a,partition+1,hi);
    }

    //对数组a中，从索引lo到索引hi之间的元素进行分组，并返回分组界限对应的索引
    public static int partiton(Comparable[] a,int lo,int hi){
        //确定分界值
        Comparable key = a[lo];
        //定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置
        int left =lo;
        int right = hi+1;

        //切分
        while (true){
            //先从右往左扫描,移动right指针，找到一个比分界值小的元素，停止
            while (less(key,a[--right])){
                if (right==lo){
                    break;
                }
            }

            //再从左往右扫描，移动left指针，找到一个比分界值大的元素，停止
            while (less(a[++left],key)){
                if (left==hi){
                    break;
                }
            }
            //判断left>=right,如果是，则证明元素扫描完毕，结束循环，如果不是，则交换元素即可
            if (left>=right){
                break;
            }else {
                exch(a,left,right);
            }
        }

        //交换分界值
        exch(a,lo,right);
        return right;
    }

    /*
      比较v元素是否小于w元素
   */
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /*
   数组元素i和j交换位置
    */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}
public class QuickTest {
    public static void main(String[] args) {
        Integer[] a= {6, 1, 2, 7, 9, 3, 4, 5, 8};
        Quick.sort(a);
        System.out.println(Arrays.toString(a));
    }

复杂度分析：最优O(nlogn) 最坏O(n^2) 平均 O(nlogn)

2.4排序稳定性

稳定性的定义：
数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证A元素依然在B元素的前面，可以说这个该算法是稳定的。
稳定性的意义：
如果一组数据只需要一次排序，则稳定性一般是没有意义的，如果一组数据需要多次排序，稳定性是有意义的。例如要排序的内容是一组商品对象，第一次排序按照价格由低到高排序，第二次排序按照销量由高到低排序，如果第二次排序使用稳定性算法，就可以使得相同销量的对象依旧保持着价格高低的顺序展现，只有销量不同的对象才需要重新排序。这样既可以保持第一次排序的原有意义，而且可以减少系统开销。
常见排序算法的稳定性：
冒泡排序：
只有当arr[i]>arr[i+1]的时候，才会交换元素的位置，而相等的时候并不交换位置，所以冒泡排序是一种稳定排序算法。
选择排序:
选择排序是给每个位置选择当前元素最小的,例如有数据{5(1)，8 ，5(2)， 2， 9 },第一遍选择到的最小元素为2，所以5(1)会和2进行交换位置，此时5(1)到了5(2)后面，破坏了稳定性，所以选择排序是一种不稳定的排序算法。
插入排序：
比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
希尔排序：
希尔排序是按照不同步长对元素进行插入排序 ,虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。
归并排序：
归并排序在归并的过程中，只有arr[i]<arr[i+1]的时候才会交换位置，如果两个元素相等则不会交换位置，所以它并不会破坏稳定性，归并排序是稳定的。
快速排序：
快速排序需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元素，然后交换这两个元素，此时会破坏稳定性，所以快速排序是一种不稳定的算法。