常见的七大排序(冒泡,插入,选择,归并,堆,快速,希尔)

一:直接插入排序

原理:
整个区间被分为:

1. 有序区间
2. 无序区间

每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

//插入排序
public static void inSort(int[] n){
        for (int i = 1; i < n.length; i++) {
            int tmp = n[i];
            int j = i - 1;
            for (; j >= 0 &&n[j] > tmp; j--) {
                n[j+1] = n[j];
            }
            n[j + 1] = tmp;
        }
    }

二:希尔排序

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

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

//希尔排序;
    public static void shellSort(int[] n){
        int gap = n.length;
        while (gap > 1 ){
            inSortGap(n,gap);
            gap = (gap / 3) + 1;//或者是 gap = gap / 2;最佳gap需要计算;
        }
        inSortGap(n,1);
    }
    public static void  inSortGap(int[] n,int gap){
        for (int i = 1; i < n.length; i++) {
            int tmp = n[i];
            int j = i - gap;
            for (; j >= 0 && n[j] > tmp; j -= gap) {
                n[j + gap] = n[j];
            }
            n[j + gap] = tmp;
        }
    }

三:选择排序

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

//选择排序;
    public static void  selectSort(int[] n){
        for (int i = 0; i < n.length-1; i++) {
            int max = 0;
            //无序区间[0,n.length-i-1);
            // 有序区间[n.length-i-1,n.length-1);
            for (int j = 1; j < n.length-i; j++) {
                if (n[j] > n[max]){
                    max = j;
                }
            }
            swap(n,max,n.length-1-i);
        }
    }
    public static void swap(int[] array,int a,int b){
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

四:堆排序

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

//堆排序;
    public static void  heapSort(int[] n){
        //先把数组建堆,升序建大堆,降序建小堆;
        creatHeap(n,n.length);
        for (int i = 0; i < n.length; i++) {
            //每次将堆顶元素与堆尾交换;
            //再进行向下调整;
            swap(n,0,n.length-1-i);
            //无序区间[0,n.length-i-1),有序区间[n.length-i-1,n.length);
            shiftDown(n,n.length-1-i,0);
        }
    }
    public static void creatHeap(int[] n,int size){
        for (int i=(size-1)/2; i >= 0;i--) {
            shiftDown(n,size,i);
        }
    }
    public static void shiftDown(int[] n,int size,int parent){
        int left = parent * 2 +1;
        while (left < size){
            int right = parent * 2 + 2;
            int max = left;
            if(right < size){
                if(n[right] > n[left]){
                    max = right;
                }
            }
            if (n[parent] >= n[max]){
                break;
            }
            swap(n,parent,max);
            parent = max;
            left = max * 2 + 1;
        }
    }
    public static void swap(int[] array,int a,int b){
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

五:冒泡排序

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

//冒泡排序法;
    public static void bubbleSort(int[] n){
        for (int i = 0; i < n.length - 1 ; i++) {
            for (int j = 0; j <n.length - i -1 ; j++) {
                if(n[j] > n[j+1]){
                    swap(n,j,j+1);
                }
            }
        }
    }
    public static void swap(int[] array,int a,int b){
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

六:快速排序

原理:

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

//快速排序;
    public static void quickSort(int[] n){
        quickSortInternal(n,0,n.length-1);
    }
    public static void quickSortInternal(int[] n,int left ,int right){
        if (left >= right){
            return;
        }
        int pivotIndex = partition(n,left,right);
        //递归排序基准左侧;
        quickSortInternal(n,left,pivotIndex-1);
        //递归排序基准右侧;
        quickSortInternal(n,pivotIndex+1,right);
    }
    public static int  partition(int[] n,int left,int right){
        int i = left;
        int j = right;
        int pivot = n[left];//将第一个作为基准;
        while (i < j){
            //从区间两侧开始
            //右侧找到比基准小的值;
            while (i < j && n[j] >= pivot){
                j--;
            }
            //左侧找到比基准大的值;
            while (i < j && n[i] <= pivot){
                i++;
            }
            //将两个值进行交换;
            swap(n,i,j);
        }
        //最后将基准与左侧区间(比基准小的数)中最后一个元素交换;
        //此时基准左侧数值都比基准小,右侧都比基准大;
        swap(n,i,left);
        //返回基准下标;
        return i;
    }
    public static void swap(int[] array,int a,int b){
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

七:归并排序

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

海量数据的排序问题:
外部排序：排序过程需要在磁盘等外部存储进行的排序前提：内存只有 1G，需要排序的数据有 100G因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

1. 先把文件切分成 200 份，每个 512 M
2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
3. 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

//归并排序;
    public static void mergeSort(int[] n){
        mergeSortInternal(n,0,n.length);
    }
    public static void mergeSortInternal(int[] n,int low,int high){
        if (low >= high-1){
            return;
        }
        int mid = (low + high) / 2;
        mergeSortInternal(n,low,mid);
        mergeSortInternal(n,mid,high);
        merge(n,low,mid,high);
    }
    public static void  merge(int[] n,int low,int mid,int high){
        int i = low;
        int j = mid;
        int length = (high - low);
        int[] extra = new int[length];
        int k = 0;
        while (i < mid && j < high){
            if (n[i] <= n[j]){
                extra[k++] = n[i++];
            }else {
                extra[k++] = n[j++];
            }
        }
        //当一半组元素先被放入排序数组后,将剩下的元素直接放入排序数组中;
        while (i < mid){
            extra[k++] = n[i++];
        }
        while (j < high){
            extra[k++] = n[j++];
        }
        //再将排序后的extra转移到原来的数组n中;
        for (int t = 0; t < extra.length; t++) {
            n[low + t] = extra[t];
        }
    }
    public static void swap(int[] array,int a,int b){
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

排序复杂度总结