七种最常用排序算法

1.直接插入排序：

原理：

整个区间被分为 1. 有序区间；
2. 无序区间 每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。

代码如下

//直接插入排序
    public static void insertSort(int[] array){
        for(int i = 1; i < array.length; i++){
            int j = i-1;
            int tmp = array[i];
            for(; j >= 0; j--){
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                   break;
                }
            }
            array[j+1] = tmp;
        }
    }

2.希尔排序：

原理：

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排序。

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

代码如下：

//希尔排序
    public static void sellSort(int[] array){
        int[] arr = {5,3,1};
        for(int i = 0; i < arr.length; i++){
            sell(array,arr[i]);
        }
    }

    public static void sell(int[] array, int gap){
        for(int i = gap; i < array.length; i++){
            int tmp = array[i];
            int j = i-gap;
            for(; j >= 0; j -= gap){
                if(array[j] > tmp ){
                    array[j+gap] = array[j];
                }else{
                    break;
                }
            }
            array[j+gap] = tmp;
        }

    }

3.直接选择排序：

原理：

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。

//直接选择排序
    public static void selectSort(int[] array){
        for(int i = 0; i < array.length-1; i++){
            for(int j = i+1; j < array.length;j++){
                if(array[j] < array[i]){
                    int tmp = array[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
        }
    }

4.冒泡排序：

原理：

无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。

代码如下：

//冒泡排序
    public static void bubbleSort(int[] array){
        for(int i = 0; i < array.length-1; i++){
            boolean flag = true;
            for(int j = 0; j < array.length-i-1; j++){
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
    }

5.快速排序：

原理：（分治思想）

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 为1，代表已经有序，或者小区间的长度 为 0，代表没有数据。

代码如下：

//快排（可优化）（分治思想）
  public static void quickSort(int[] array, int low, int high){
 
        if(low < high){  // if(low > high)return;
            int piv = pivot(array,low,high);
            quickSort(array,low,piv-1);
            quickSort(array,piv+1,high);
        }
    }
    public static int pivot(int[] array, int start, int end){
        int tmp =arr[start];
        while(start < end ){
            while(start < end && arr[end] >= tmp ){
                end--;
            }
            arr[start] = arr[end];

            while(start < end && arr[start] <= tmp){
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = tmp;
        return start;

    }

非递归代码如下：

//快排--》非递归
    public static void quickSortNor(int[] array){
        Stack<Integer> stack = new Stack<>();
        int low = 0;
        int high = array.length-1;
        int piv = pivot(array,low,high);
        if(piv > low + 1) {
            stack.push(low);
            stack.push(piv-1);
        }
        if(piv < high-1) {
            stack.push(piv+1);
            stack.push(high);
        }
        while (!stack.empty()) {
            high = stack.pop();
            low = stack.pop();
            piv = pivot(array, low, high);//
            if (piv > low + 1) {
                stack.push(low);
                stack.push(piv - 1);
            }
            if (piv < high - 1) {
                stack.push(piv + 1);
                stack.push(high);
            }

        }

    }

6.归并排序：

原理：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

代码如下：

//归并排序
    public static void mergeSort(int[] array,int low,int high){
        if(low >= high){
            return;
        }
        int mid = (low+high)/2;// =(low+high)>>>1;  无符号右移；
        mergeSort(array,low,mid);
        mergeSort(array,mid+1,high);
        merge(array,low,mid,high);


    }
    public static void merge(int[] array,int low,int mid,int high){
        int s1 = low;
        int s2 = mid+1;
        int[] ret = new int[high-low+1];
        int i = 0;
        while(s1 <= mid && s2 <= high){
            if(array[s1] <= array[s2]){
                ret[i++] = array[s1++];
            }else{
                ret[i++] = array[s2++];
            }
        }
        while(s1 <= mid){
            ret[i++] = array[s1++];
        }
        while(s2 <= high){
            ret[i++] = array[s2++];
        }
        for(int j = 0; j < ret.length; j++){
            array[j+low] = ret[j];
        }
    }

非递归代码如下：

//非递归归并排序

    public static void mergeSortNor(int[] array) {
        for (int i = 1; i < array.length; i*=2) {
            merge(array,i);
        }
    }
    public static void merge(int[] array,int gap) {

        int s1 = 0;
        int e1 = s1+gap-1;
        int s2 = e1+1;
        int e2 = s2+gap-1 < array.length ? s2+gap-1 : array.length-1;

        int[] tmp = new int[array.length];
        int k = 0;//下标

        //当有两个归并段的时候
        while (s2 < array.length) {
            //当有两个归并段 且 这两个段内都要数据
            while (s1 <= e1 && s2<= e2) {
                if(array[s1] <= array[s2]) {
                    tmp[k++] = array[s1++];
                }else{
                    tmp[k++] = array[s2++];
                }
            }
            while (s1 <= e1) {
                tmp[k++] = array[s1++];
            }
            while (s2 <= e2){
                tmp[k++] = array[s2++];
            }
            //从这里开始的时候，每个下标都可能越界
            s1 = e2+1;//
            e1 = s1+gap-1;
            s2 = e1+1;
            e2 = s2+gap-1 < array.length ? s2+gap-1 : array.length-1;
        }

        //退出上面循环后，
        // 那么把s1段内的数据给拷贝下来,因为 有可能e1已经越界了
        while (s1 < array.length) {
            tmp[k++] = array[s1++];
        }

        for (int i = 0; i < tmp.length; i++) {
            array[i] = tmp[i];
        }

    }

7.堆排：

原理：

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意： 排升序要建大堆；排降序要建小堆。

代码如下：

 //堆排
    public static void heapSort(int[] array){
        creatHeap(array);
        for(int i = 0; i < array.length-1; i++){
            int tmp = array[0];
            array[0] = array[array.length-1-i];
            array[array.length-1-i] = tmp;
            adjustDown(array,array.length-1-i,0);
        }

    }


    public static void creatHeap(int[] array){
        for(int i = (array.length-1-1)/2; i >=0; i--){
            adjustDown(array,array.length,i);
        }
    }

    public static void adjustDown(int[] array,int len, int parent){
        int child = 2*parent+1;
        while(child < len){
            if(child+1 < len && array[child+1] > array[child]){
                child++;
            }
            if(array[child] > array[parent]){
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                parent = child;
                child = 2*parent+1;
            }else{
                break;
            }
        }
    }

性能分析：

排序方法	最好	平均	最坏	空间复杂度	稳定性
冒泡排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
希尔排序	O(n)	O(n^1.3)	O(n^2)	O(1)	不稳定
快速排序	O(n*log(n))	O(n*log(n))	O(n^2)	O(log(n))~O(n)	不稳定
堆排序	O(n*log(n))	O(n*log(n))	O(n*log(n))	O(1)	不稳定
归并排序	O(n*log(n))	O(n*log(n))	O(n*log(n))	O(n)	稳定