排序方法总结

时间复杂度

常见的时间复杂度，按数量级递增排列依次为：常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n^{2)、立方阶O(n}3)、k次方阶O(n^{k)、指数阶O(2}n)。常见的算法时间复杂度由小到大依次为：

                           c < log2N < n < n * Log2N < n^2 < n^3 < 2^n < 3^n < n!

其中c是一个常量，如果一个算法的复杂度为c 、 log2N 、n 、 n*log2N ,那么这个算法时间效率比较高

排序

冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
选择排序、希尔排序、快速排序、堆排序不是稳定的排序算法，

希尔排序：
希尔排序：最好的情况有序，复杂度为O(nlgn)；最差的情况是O(N^2),但平均复杂度要比直接插入小，不稳定算法

冒泡排序：
1、冒泡排序是一种用时间换空间的排序方法，n小时好
2、最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序，最差时间复杂度O(N^2)只是表示其操作次数的数量级
3、最好的情况是数据本来就有序，复杂度为O(n)，但是需要对代码变形，参考3.2节

快速排序：
1、n大时好，快速排序比较占用内存，内存随n的增大而增大，但却是效率高不稳定的排序算法。
2、划分之后一边是一个，一边是n-1个，这种极端情况的时间复杂度就是O(N^2)
3、最好的情况是每次都能均匀的划分序列，O(N*log2N)

归并排序：
1、n大时好，归并比较占用内存，内存随n的增大而增大，但却是效率高且稳定的排序算法。

1.1插入排序（for）

    //插入排序， O(n2)  O(n)正序或者倒叙  O(n2)  ||  O(1) 稳定排序
    public static void insertSort(int[] nums) {
   
        int len = nums.length;
        int temp, j;
        for (int i = 1; i < len; i++) {
   
            temp = nums[i];
            if (nums[i - 1] > temp) {
   
                for (j = i-1; j >=0 && nums[j]>temp; j--) {
   
                    nums[j+1] = nums[j];
                }
                nums[j+1] = temp;
            }
        }
    }

1.2插入排序(while)

    //插入排序， O(n2)  O(n)  O(n2)  ||  O(1) 稳定排序
    public static void insertSort1(int[] nums) {
   
        int len = nums.length;
        int temp, j;
        for (int i = 1; i < len; i++) {
   
            temp = nums[i];
            if (nums[i - 1] > temp) {
   
                j = i - 1;
                while (j >= 0 && nums[j] > temp) {
   
                    nums[j + 1] = nums[j];
                    j--;
                }
                nums[j + 1] = temp;
            }
        }
    }

1.3二分查找排序

    //二分查找排序 O(nlgn) O(n) O(nlgn)  || O(1)  稳定
    public static void binarySort(int[] nums) {
   
        int len = nums.length;
        int temp, low, high, mid;
        for (int i = 1; i < len; i++) {
   
            if (nums[i - 1] > nums[i]) {
   
                temp = nums[i];
                low=0;
                high = i - 1;
                while (low <= high) {
   
                    mid = (low + high) / 2;
                    if (nums[mid] <= temp) {
   
                        low = mid + 1;
                    } else {
   
                        high = mid - 1;
                    }
                }

                for (int j = i - 1; j >= low; j--) {
   
                    nums[j + 1] = nums[j];
                }
                //nums[j+1] = temp;
                nums[low] = temp;
            }
        }
    }

2.1希尔排序

    //希尔排序 O(n1.3) O(n) O(n2) || O(1)  不稳定
    public static void shellSort(int[] nums) {
   
        int len = nums.length;
        int gap = len