排序

直接插入排序

原理：每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。
性能分析：

• 时间复杂度： 最好：O(n) ；最坏：O(n^2)
• 空间复杂度： O(1)
• 稳定性：稳定排序

java代码实现：

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

希尔排序

原理：先取一个小于n的整数gap作为第一个增量，把待排序文件的全部记录分组。所有距离为gap的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量，即所有记录放在同一组中进行直接插入排序为止。
性能分析：

• 时间复杂度： 最好：O(n) ；最坏：O(n^2)
• 空间复杂度： O(1)
• 稳定性：不稳定排序

java代码实现：

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

public static void shellSort(int[] array) {
        int[] drr = {5,3,1};
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
        }
    }

堆排序

原理：创建大根堆，将堆顶元素和最后一个元素进行交换， 交换完之后，调整0号下标这棵树。
性能分析：

• 时间复杂度： O(nlogn)
• 空间复杂度： O(1)
• 稳定性：不稳定排序

java代码实现：

public static void createHeap(int[] array){
        for (int i = (array.length-1-1)/2; i >= 0 ; i--) {
            adjustDown(array,i,array.length);
        }
    }
    
public static void adjustDown(int[] array,int root,int len){
        int parent = root;
        int child = 2*parent+1;
        //有左孩子
        while (child<len){
            if(child+1 < len && array[child] < array[child+1]){
                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;
            }
        }
    }
    
public static void heapSort(int[] array){
        //创建大根堆
        createHeap(array);
        //堆顶元素和最后一个元素进行交换
        int end = array.length-1;
        while (end>0){
            int tmp = array[0];
            array[0] = array[end];
            array[end] = tmp;
            adjustDown(array,0,end);
            end--;
        }
    }

选择排序

原理：每次从待排序数字的后面，选取一个比当前数字小的数据进行交换，直到把当前的序列遍历完成。
性能分析：

• 时间复杂度： O(n^2)
• 空间复杂度： O(1)
• 稳定性：不稳定排序

java代码实现：

public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length; j++) {
                if(array[i]>array[j]){
                    int tmp = array[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
        }
    }

冒泡排序

原理：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。
性能分析：

• 时间复杂度： O(n^2)；最好：优化之后为O(n)
• 空间复杂度： O(1)
• 稳定性：稳定排序

java代码实现：

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

快速排序

原理：从待排序区间选择一个数，作为基准值；然后遍历整个待排序区间，将比基准值小的放到基准值的左边，将比基准值大的放到基准值的右边；采用分治思想，对左右两个小区间按照同样的方式处理，直到将整个待排序序列划分完毕，即小区间的长度为1，代表已经有序。
性能分析：

• 时间复杂度： O(n*logn)
• 空间复杂度： O(log(n))
• 稳定性：不稳定排序

基准值的选择：

• 选择边上（左或者右）
• 随机选择
• 三数取中法：array[left], array[mid], array[right] 大小是中间的为基准值

java代码实现：

public static void quickSort(int[] array,int left,int right){
       if(left >= right){
            return;
        }
        int pivot = partion(array,left,right);
        quickSort(array, left, pivot - 1);
        quickSort(array, pivot + 1, right);
    }

    //挖坑法
 public static int partion(int[] array,int left,int right) {
        int tmp = array[left];
        while (left < right){
            while (left<right && array[right]>=tmp){
                right--;
            }
            if(left>=right){
                break;
            }else {
                array[left] = array[right];
            }
            while (left<right && array[left]<=tmp){
                left++;
            }
            if(left>=right){
                break;
            }else {
                array[right] = array[left];
            }
        }
        array[left] = tmp;
        return left;
    }

归并排序

原理：先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
性能分析：

• 时间复杂度： O(n * log(n))
• 空间复杂度： O(n)
• 稳定性：稳定排序

java代码实现：

public static void mergeSort(int[] array,int low,int high){
        if(low >= high)
            return;
        int mid = (low+high)/2;
        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 len = high - low + 1;
        int[] tmp = new int[len];//每次合并之后的数组大小
        int i = 0;
        while (s1 <= mid && s2 <= high){
            if(array[s1] <= array[s2]){
                tmp[i++] = array[s1++];
            }else {
                tmp[i++] = array[s2++];
            }
        }
        while (s1 <= mid){
            tmp[i++] = array[s1++];
        }
        while (s2 <= high){
            tmp[i++] = array[s2++];
        }
        //把临时数组内的数据，拷贝到原有的数组中
        for (int j = 0; j < len; j++) {
            array[low+j] = tmp[j];
        }
    }