八种排序算法（直接插入，希尔，直接选择，堆，冒泡，快排，归并，基数）

一，直接插入排序：

将一个数据插入到已经排好序的有序数据中。算法适用于少量数据的排序，平均时间复杂度和最坏时间复杂度都是O(n^2)，最好时间复杂度是O(n)。空间复杂度O(1)。是稳定的排序方法。Java代码：

//直接插入排序
private static int[] insertSort(int[] arr){
    if(arr == null || arr.length < 2){
        return arr;
    }
    for(int i=1;i<arr.length;i++){
        for(int j=i;j>0;j--){
            if(arr[j] < arr[j-1]){//插入，并将插入位置之后的数后移一位。
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }else{
                break;//要插入的数比之前的都大，不用插入，直接比下一个。
            }
        }
    }
    return arr;
}

二，希尔排序：

又称缩小增量排序，实质上是一种分组插入排序。一般先取整数d1作为第一个增量，它是序列长度的一半，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2，它是d1的一半，重复上述的分组和排序，直至所取的增量为1，即所有记录放在同一组中进行直接插入排序为止。
当增量d很大时，数据项每一趟排序移动的元素个数少，但移动的距离很长，这是非常高效的；当d减小时，每一趟排序移动的元素个数增加，但此时的数据项已经接近于他们最终排序后的位置，插入排序可以更有效。
希尔排序适合中等规模的数据。时间复杂度和增量选取有关，一般来说平均时间复杂度是O(n^1.3)，最好是O(n)，最坏是O(n^2)。空间复杂度为O(1)。希尔排序是不稳定的。Java代码：

//希尔排序
public static void shellSort(int[] arr) {
    if(arr == null || arr.length <= 1){
        return;
    }
    int d = arr.length/2;//增量
    while(d >=1){
        for(int i=0;i<arr.length;i++){
            //进行插入排序
            for(int j=i;j<arr.length-d;j=j+d){
                if(arr[j] > arr[j+d]){
                    int temp = arr[j];
                    arr[j] = arr[j+d];
                    arr[j+d] = temp;
                }
            }
        }
        d = d/2;//设置新的增量
    }
}

三，直接选择排序：

三种情况下的时间复杂度都是O(n^2)。空间复杂度为O(1)。是不稳定的排序算法。Java代码（一轮排序后，第一个位置肯定是最小的）：

//直接选择排序
public static void selectSort(int[] arr) {
    if(arr == null || arr.length <= 1){
        return;
    }
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

四，堆排序：

堆是一个完全二叉树，如果按照层序遍历结果存储为数组，下标为i且根节点i=0，则满足Key[i]>=Key[2i+1]&&Key[i]>=key[2i+2]的称为大根堆，即根结点大于子结点，堆顶为最大值。
堆排序第一步建堆，即将输入序列看作是层序遍历结果，然后按顺序写成完全二叉树的形式。第二步调整堆，即从最后一个非叶结点开始调整，它的数组下标为最后一个数的下标-1之后除以2，保证这个结点比子结点大。然后下标减一继续调整，交换结点之后的孩子结点有可能不满足堆的性质，继续调整直到下标为0，这里有递归和非递归两种方法。
堆排序就是根据前边建好的堆先取出根结点和最后一个结点交换，然后对前边len-1个结点进行堆调整，再取出根结点和倒数第二个结点交换，对前边len-2个结点堆调整，以此类推直到所有结点都取出。
heapAdjust函数可看做每次都从当前结点走到叶子节点，数高度为log(n+1)向上取整，所以复杂度可视为O(logn)，简单起见，不必考虑到底是从根节点到达叶结点还是从中间某节点到达叶结点。建堆时调用heapAdjust函数n/2次，排序时调用heapAdjust函数n-1次，得到三种情况下的复杂度都是O(logn)* (n/2)+O(logn)*(n-1)，化简为O(nlogn)。空间复杂度O(1)。是不稳定的排序。Java代码：

//堆排序，执行之前要先建堆！(以大根堆为例)
void heapSort(int[] array){
    if(array == null || array.length<2){
        return;
    }
    for(int i = array.length-1;i>0;i--){
        int temp = array[0];
        array[0] = array[i];
        array[i] = temp;
        heapAdjust(array, i, 0);
    }
}
//建堆
void buildHeap(int[] array){
    if(array == null || array.length<2){
        return;
    }
    for(int i = (array.length-2) >> 1; i >= 0; i--){//这里初始i是最后一个非叶结点的数组下标
        heapAdjust(array, array.length, i);//调整堆
    }
}
//调整堆，递归法，参数heapSize为要调整的堆的大小，参数parent为当前堆顶的数组下标
void heapAdjust(int[] array,int heapSize,int parent){
    int left = 2*parent+1;//左孩子下标
    int right = left+1;//右孩子下标
    int largest = parent;//最大值下标
    if(left < heapSize && array[left] > array[parent]){
        largest=left;
    }
    if(right < heapSize && array[right] > array[largest]){
        largest=right;
    }
    //交换之后子结点可能就不满足堆的特性了，要继续调整
    if(largest != parent){
        int temp = array[parent];
        array[parent] = array[largest];
        array[largest] = temp;
        heapAdjust(array, heapSize, largest);
    }
}

五，冒泡排序：

平均时间复杂度O(n^2)，最好情况O(n)，最坏情况O(n^2)。空间复杂度O(1)。是稳定的排序。Java代码（一轮排序后，最大的数会在最后的位置）：

//冒泡排序
private static void bubbleSort(int[] arr){
    if(arr == null || arr.length<2){
        return;
    }
    for(int i=arr.length-1;i>0;i--){
        for(int j=0;j<i;j++){
            if(arr[j] > arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

六，快速排序：

平均时间复杂度为O(nlogn)，最好情况也是O(nlogn)，最坏情况为O(n^2)。空间复杂度为O(logn)，用栈实现递归，调用logn次。不稳定。Java代码：

//快排，left和right为待排数组左右两端的下标
private static void quickSort(int[] arr,int left,int right){
    if(arr == null || arr.length<2 || left>=right){
        return;
    }
    int i = left;
    int j = right;
    int key = arr[left];//以左边第一个数为基准
    while(i<j){
        while(i<j && arr[j]>=key){//从右向左，找比基准值小的数，然后换到前边。
            j--;
        }
        arr[i] = arr[j];
        while(i<j && arr[i]<=key){//从左往右，找比基准值大的数，然后换到后边。
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = key;//排完一趟后,把基准值放在了它最终应该在的位置
    quickSort(arr, left, i-1);
    quickSort(arr, i+1, right);
}

七，归并排序：

以二路归并为例，把序列看成两个子序列，分别排序后合并，子序列也可看成两个子序列，递归下去。最终结果就是序列中的相邻两个元素先合并成一个有序的小序列，然后相邻的两个小序列再合并成包含四个元素的有序序列，以此类推。
速度仅次于快排，优点是它是稳定的排序。三种情况下的时间复杂度都是O(nlogn)。空间复杂度为O(n)。是稳定的排序。Java代码：

//二路归并，left和right为待排数组两端下标
public static void mergeSort(int[] arr,int left,int right) {
    if(arr == null || arr.length<2 || left >= right){
        return;
    }
    int mid = (left + right) / 2;
    mergeSort(arr, left, mid);//左子序列
    mergeSort(arr, mid+1, right);//右子序列
    merge(arr,left,mid,right);//合并
}
//两个序列为[left, mid]和[mid+1, right]
public static void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1]; //临时数组，大小为两个子序列的和
    int i = left;//左子序列的起始下标
    int j = mid + 1;//右子序列的起始下标
    int k = 0;//临时数组的下标
    while(i <= mid && j <= right) {//临时数组中存放合并后的序列
        if(arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        }else {
            temp[k++] = arr[j++];
        }
    }
    while(i <= mid) {
        temp[k++] = arr[i++];
    }
    while(j <= right) {
        temp[k++] = arr[j++];
    }
    for(int p=0; p<temp.length; p++) {//合并后的序列
        arr[left + p] = temp[p];
    }
}

八，基数排序：

是一种线性排序方法，基数是指键值的取值范围，比如对数字来说就是0到9，键值就是位数。具体是将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零；然后，按照最低位的大小进行一次排序得到一个序列（分配和收集：分配是遍历所有数，分给对应的0到9；收集是按顺序从0到9中取出数组成序列），再对这个序列按照次低位的大小进行一次排序，以此类推。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。
设待排序列为n个数字，d个键值（数字最多有几位），键值的取值范围为radix（对数字来说是0到9），则基数排序的三种情况下的时间复杂度都为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。空间复杂度为O(2*radix)，存放队列的头尾指针（如果是链表存储的话）。是稳定的排序。Java代码：

//基数排序，d表示最大的数有多少位
public static void radixSort(int[] arr, int d){ 
    int k = 0;
    int n = 1;//取出数字的某一位时用到
    int m = 1; //1表示从最低位开始排序
    //分配步骤的临时数组，第一维表示可能的余数0-9，即键值的范围。
    int[][] temp = new int[10][arr.length]; 
    //数组count[i]用来表示该位是i的数的个数
    int[] count = new int[10]; 
    while(m <= d){
        for(int i = 0; i < arr.length; i++){//分配
            int lsd = ((arr[i] / n) % 10);//lsd原意是从最低位开始排序的意思，这里表示最低位的值
            temp[lsd][count[lsd]] = arr[i];
            count[lsd] = count[lsd] + 1;
        }
        for(int i = 0; i < 10; i++){//收集
            if(count[i] != 0){
                for(int j = 0; j < count[i]; j++){
                    arr[k++] = temp[i][j];
                }
            }
            count[i] = 0;//重置count数组
        }
        n *= 10;
        k = 0;
        m++;
    }
}

九，总结：

1，以上8种排序可细分为4类：

• 插入类：包括直接插入排序和希尔排序。
• 选择类：包括直接选择排序和堆排序。
• 交换类：包括冒泡排序和快速排序。
• 其它类：包括归并排序和基数排序（是一种线性排序）。

2，关于时间复杂度：

• O(n^2)级别：直接插入，直接选择，冒泡。即三种类型的简单排序。
• O(nlogn)级别：快排，堆排序，归并排序。
• 其它，比如O(n)级别是基数排序，希尔排序和增量选择有关。

3，空间复杂度：快排O(logn)，归并O(n)，基数排序O(2r)。
4，记住不稳定算法的顺口溜：快些选堆（快排，希尔，选择，堆）。