十大经典排序算法（图解与代码）——冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序（Python and Java）

排序

重新排列表中的元素，使表中的元素按照关键字递增或者递减

内部排序：

指在排序期间，元素全部存放在内存中的排序

外部排序：

指在排序期间元素无法全部同时存放在内存中，必须在排序的过程中根据要求不断地在内、外存之间进行移动

算法的时间复杂度

时间频度：

一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。

一个算法中的语句执行次数称为语句频度或时间频度。记为 $T(n)$

统计时间频度是，可以忽略常数项，忽略低次项，并忽略高次项的系数

时间复杂度：

一般情况下，算法中的基本操作语句的重复执行次数是问题规模 $n$ 的某个函数，用 $T(n)$ 表示，若有某个辅助函数 $f(n)$，使得当 $n$ 趋近于无穷大时，$T(n)/f(n)$ 的极限值为不等于零的常数，则称 $f(n)$ 是 $T(n)$ 的同数量级函数。

记作 $T(n)=Ｏ(f(n))$，称 $Ｏ(f(n))$ 为算法的渐进时间复杂度，简称时间复杂度。

$T(n)$ 不同，但时间复杂度可能相同。

如：T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的T(n) 不同，但时间复杂度相同，都为O(n²)。

计算时间复杂度的方法：

用常数 $1$ 代替运行时间中的所有加法常数

$T(n)=n²+7n+6=>T(n)=n²+7n+1$

修改后的运行次数函数中，只保留最高阶项

$T(n)=n²+7n+1=>T(n)=n²$

去除最高阶项的系数

$T(n)=n²=>T(n)=n²=>O(n²)$

常见时间复杂度

常见的算法时间复杂度由小到大依次为：

$O(1)＜O(lo{g}_{2}n)＜O(n)＜O(nlo{g}_{2}n)＜O(n^2)＜O(n^3)＜O(n^k)＜O(2^n)<O(n!)$

随着问题规模 $n$ 的不断增大，上述时间复杂度不断增大，算法的执行效率越低

平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。

最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。

这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。

平均时间复杂度和最坏时间复杂度是否一致，和算法有关

算法的空间复杂度

一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模 $n$ 的函数。

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模 $n$ 有关，它随着 $n$ 的增大而增大，当 $n$ 较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况

在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间.

排序算法的稳定性

若待排序的表中有两个元素 $R_i$ 和 $R_j$，其对应的关键字 $k_i=k_j$，且在排序前 $R_i$ 是在 $R_j$ 前面的，若使用某排序算法后，$R_i$ 仍在 $R_j$ 前面；则称这个排序算法是稳定的，否则称排序算法不稳定

交换排序

冒泡排序

冒泡排序是一个稳定的算法

基本思想：

假设待排序表长为 $n$，从后向前（或者从前往后），两两比较相邻元素的值，若为逆序（即 a[i - 1] > a[i]），则交换它们顺序，直到序列比较结束

一次冒泡，可以将一个元素放置到它最终的位置上

因为排序的过程中，各元素不断接近自己的位置 如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换从，而减少不必要的比较

冒泡排序规则：

1. 一共进行 数组的大小-1 次大的循环
2. 每一趟排序的次数在逐渐的减少
3. 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化

代码

• Python

def bubble_sort(nums):
    len_nums = len(nums)
    for i in range(1, len_nums):
        # flag 为 1，表示此次循环没有进行交换，已完成排序
        flag = 1
        for j in range(len_nums-i):
            if nums[j] > nums[j+1]:
                temp = nums[j]
                nums[j] = nums[j+1]
                nums[j+1] = temp
                flag = 0
        if flag == 1:
            break
    return nums

• Java

package data.structure.sort;
import java.util.Arrays;
public class bubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {3, 9, -1, 10, -2};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        int temp;
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) { // 一次排序中都没有进行排序
                break;
            } else {
                flag = false;
            }
        }
    }
}

空间复杂度：

$O(1)$

既适用于顺序存储，也适用于链式存储

时间复杂度：

最好时间复杂度：$O(n)$

最坏时间复杂度：$O(n^2)$

平均时间复杂度：$O(n^2)$

快速排序

快速排序是一个不稳定的排序算法

基本思想：

在待排序的表 L[1...n] 中任取一个元素 pivot 作为基准，通过一趟排序将排序表换分为具有如下特点的两部分：

一次划分，会将一个元素 pivot 放置到它的最终位置上

基本思路：

初始化标记 low 为划分部分第一个元素的位置，high 为最后一个元素的位置，然后不断地移动两个标记，并交换元素：

1. high 向前移动找到第一个比 pivot 小的元素
2. low 向后移动找到第一个比 pivot 大的元素
3. 交换当前两个位置的元素
4. 继续移动标记，执行 1、2、3 的过程，直到 low 大于等于 high 为止

代码

• Python

def quick_sort(nums, left, right):
    if left < right:
        partition_index = partition(nums, left, right)
        quick_sort(nums, left, partition_index-1)
        quick_sort(nums, partition_index+1, right)
    return nums
def partition(nums, left, right):
    pivot = left
    index = pivot + 1
    for i in range(index, right+1):
        if nums[i] < nums[pivot]:
            swap(nums, i, index)
            index += 1
    swap(nums, pivot, index-1)
    return index - 1
def swap(nums, i, j):
    temp = nums[i]
    nums[i] = nums[j]
    nums[j] = temp

• Java

package data.structure.sort;
import java.util.Arrays;
public class QuickSortDemo {
    public static void main(String[] args) {
        int[] arr = {-9, 78, 0, 23, -5, 70, 900, -560, 893};
        System.out.println(Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right) {
        int l = left;  // 左下标
        int r = right; // 右下标
        int pivot = arr[(left + right) / 2];
        int temp;
        // 通过 while 循环，将比 pivot 值小的放到左边
        // 将比 pivot 值大的放到右边
        while (l < r) {
            // 找到比 pivot 值小于等于的值
            while (arr[l] < pivot) {
                l += 1;
            }
            // 找到比 pivot 值大于等于的值
            while (arr[r] > pivot) {
                r -= 1;
            }
            if (l >= r) {  // 说明 pivot 左右两边的值满足
                break;     //  左边小于 pivot；右边大于 pivot
            } else {       // l < r
                temp = arr[l];
                arr[l] = arr[r];
                arr[r] = temp;
                // 如果交换完后， arr[l] == pivot，r--，前移
                if (arr[l] == pivot) {
                    r -= 1;
                }
                // 如果交换完后，arr[r] == pivot，l++，后移
                if (arr[r] == pivot) {
                    l += 1;
                }
            }
        }
        // 一定要做如下判断，否则出现栈溢出
        // 因为是满足上述条件的，无法从循环中退出
        if (l == r) {
            l += 1;
            r -= 1;
        }
        if (left < r) {
            quickSort(arr, left, r);
        }
        if (right > l) {
            quickSort(arr, l, right);
        }
    }
}

空间复杂度：

最好和平均的空间复杂度：$O({\log }_{2}n)$

最坏的空间复杂度：$O(n)$

既适用于顺序存储，也可以适用于链式存储

时间复杂度：

最好和平均的时间复杂度：$O(n\times {\log }_{2}n)$

最坏时间复杂度：$O(n^2)$

选择排序

直接选择排序

是一个不稳定的排序算法

基本思想：

每一趟在后面 $n-i+1（i=1,2,...,n-1）$ 个待排序元素中选取关键字最小的元素，作为有序子序列的第 $i$ 个元素，直到 $n-1$ 趟做完，待排序元素只剩下 $1$ 个

每一次排序，都会将一个元素放置在最终的位置上

1. 选择排序一共有 数组大小 - 1 轮排序
2. 每1轮排序，又是一个循环, 循环的规则(代码)
   • 先假定当前这个数是最小数
   • 然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标
   • 当遍历到数组的最后时，就得到本轮最小数和下
   • 交换

代码

• Python

def select_sort(nums):
    len_nums = len(nums)
    # 共需要 n-1 次比较
    for i in range(len_nums-1):
        i_min = i
        # 每次比较 n-i 个数
        for j in range(i+1, len_nums):
            if nums[j] < nums[i_min]:
                # 记录目前找到的最小值元素的下标
                i_min = j
        # 将找到的最小值和 i 位置所在的值进行交换
        if i != i_min:
            temp = nums[i]
            nums[i] = nums[i_min]
            nums[i_min] = temp
    return nums

• Java

package data.structure.sort;
import java.util.Arrays;
public class selectSortDemo {
    public static void main(String[] args) {
        int[] arr = {101, 198, 982, 32};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void selectSort(int[] arr) {
        for (int j = 0; j < arr.length - 1; j++) {
            int minIndex = j;
            int min = arr[j];
            for (int i = j + 1; i < arr.length; i++) {
                if (arr[i] < min) {
                    min = arr[i];
                    minIndex = i;
                }
            }
            if (minIndex != j) {
                arr[minIndex] = arr[j];
                arr[j] = min;
            }
        }
    }
}

空间复杂度：

空间复杂度：$O(1)$

既适用于顺序存储，也可以适用于链式存储

时间复杂度：

时间复杂度：$O(n^2)$

时间复杂度与初始序列无关

堆排序

堆排序算法是一个不稳定的排序算法

一般升序采用大顶堆，降序采用小顶堆

堆

$n$ 个关键字序列 L[1...n] 称为 堆，当且仅当该序列满足：

1. 若 $L[i]\le L[2i]且L[i]\le L[2i+1]$，则称该堆为 小根堆（小顶堆）
2. 若 $L[i]\ge L[2i]且L[i]\ge L[2i+1]$，则称该堆为 大根堆（大顶堆）
3. $(1\le i\le \lfloor n/2\rfloor )$

在排序过程中，可以将堆 L[1...n] 视为一棵 完全二叉树 的顺序存储结构

堆的初始化（以大根堆为例）：

对所有具有双亲节点含义编号从大到小（$\lfloor n/2\rfloor ——1$）做出如下调整：

1. 若孩子节点皆小于双亲节点，则该节点的调整结束
2. 若存在孩子节点大于双亲节点，则将最大的孩子节点与双亲节点交换，并对该孩子节点进行 1、2，直到出现 1 或者到叶节点为止

堆的插入：

将新节点放置在末端，然后进行向上调整

基本思想

堆排序的基本思想是：

1. 将待排序序列构造成一个大顶堆
2. 此时，整个序列的最大值就是堆顶的根节点
3. 将其与末尾元素进行交换，此时末尾就为最大值
4. 然后将剩余 n-1 个元素重新构造成一个堆，这样会得到 n-1 个元素的次小值。如此反复执行，便能得到一个有序序列了

可以看到在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列了.

排序步骤

步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

1. .假设给定无序序列结构如下

   

2. .此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

   

3. .找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

   

4. 这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无序序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

1. .将堆顶元素9和末尾元素4进行交换

   

2. .重新调整结构，使其继续满足堆定义

   

3. .再将堆顶元素8与末尾元素5进行交换，得到第二大元素8.

   

4. 后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

代码

• Python

def heap_sort(nums):
    len_nums = len(nums)
    # 初始化为 大根堆
    build_max_heap(nums, len_nums)
    for i in range(len_nums-1, -1, -1):
        swap(nums, 0, i)
        len_nums -= 1
        heapify(nums, 0, len_nums)
    return nums
    
def build_max_heap(nums, len_nums):
    start = len_nums//2
    for i in range(start, -1, -1):
        heapify(nums, i, len_nums)
        
def heapify(nums, i, len_nums):
    left = 2*i + 1
    right = 2*i + 2
    largest = i
    if left < len_nums and nums[left] > nums[largest]:
        largest = left
    if right < len_nums and nums[right] > nums[largest]:
        largest = right
    if largest != i:
        swap(nums, i, largest)
        heapify(nums, largest, len_nums)
        
def swap(nums, i, j):
    temp = nums[i]
    nums[i] = nums[j]
    nums[j] = temp

• Java

package data.structure.tree;
import java.util.Arrays;
public class HeapSortDemo {
    public static void main(String[] args) {
        int[] arr = {4, 6, 8, 5, 9, -99, 102, -3934, 937344};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void heapSort(int[] arr) {
        System.out.println("堆排序（升序）：");
        int temp = 0;
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }
        for (int j = arr.length - 1; j > 0; j--) {
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, j);
        }
    }

    // 将一个数组（二叉树），调整成一个大顶堆
    /**
     * @param arr 待调整的数组
     * @param i   表示非叶子节在数组中索引
     * @param length  表示对多少个元素继续调整，逐渐减少
     * */
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];
        // k 是 i 的左子结点
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) { // 左子节点 < 右子节点
                k += 1;
            }
            if (arr[k] > temp) { // 子结点大于父节点
                arr[i] = arr[k]; // 把较大值赋值给当前节点
                i = k;           // i 指向 k，继续循环
            } else {
                break;
            }
        }
        // 当 for 循环结束后，以 i 为父节点的树的最大值，已放到了最顶上（局部）
        arr[i] = temp;
    }
}

空间复杂度：

空间复杂度：$O(n)$

适用于顺序存储，也可以适用于链式存储

时间复杂度：

时间复杂度：$O(n\times {\log }_{2}n)$

插入排序

插入排序：

每次将一个待排序的序列元素插入到一个前面已经拍好序的子序列中

基本思想：

把 $n$ 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 $n-1$ 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

直接插入排序

排序流程：

• 初始 L[1] 是一个已经排好序的子序列
• 对于元素 L[i] (L[2] ~L[n]) 插入到前面已经排好序的子序列当中：
  1. 查找出 L[i] 在 L[1...i-1] 中的插入位置 k
  2. 将 L[k...i-1] 中的所有元素全部后移一个位置
  3. 将 L[i] 复制到 L[k]

是一个稳定的排序算法

空间复杂度：

$O(1)$

既适用于顺序存储，也适用于链式存储

时间复杂度：

最好时间复杂度：$O(n)$

最坏时间复杂度：$O(n^2)$

平均时间复杂度：$O(n^2)$

代码

• Java

public class InsertSortDemo {
    public static void main(String[] args) {
        int[] arr = {98, 673, 459, 9, 19};
        InsertSort(arr);
    }

    public static void InsertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int insertVal =arr[i];
            int insertIndex = i - 1;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex + 1] = insertVal;
        }
    }

• Python

def insert_sort(nums):
    len_nums = len(nums)
    # 从下标为 1 的元素开始选择合适的位置插入，因为下标为 0 的只有一个元素，默认有序
    for i in range(1, len_nums):
        # 记录要插入的数据
        temp = nums[i]
        # 从已经排序的序列最右边的开始比较，找到比其小的数
        j = i
        while j>0 and temp<nums[j-1]:
            nums[j] = nums[j-1]
            j -= 1
        # 存在比其小的数，插入
        if j != i:
            nums[j] = temp
    return nums

折半插入排序

将折半查找与直接插入排序的结合，就是折半插入排序

是一个稳定的排序算法

代码

• Java

public void InsertSort(int len, int[] arrays) {
	if (len <=2) {
		return;
	}
	// arrays[0] 作为哨兵
	// 		1、保存当前要插入的元素
	// 		2、哨兵可以省去是否遍历所有元素的条件判断
	// 对 2~len 的元素进行插入排序
	for (int i = 2; i <= len; i++) {
		arrays[0] = arrays[i];
		int low = 1;
		int high = i - 1;
		// 寻找插入位置
		while (low <= high) {
			int mid = (low + high) / 2;
			if (arrays[mid] > arrays[0]) {
				high = mid - 1;
			} else {
				low = mid + 1;
			}
		}
		for (int j = i - 1; j >= high + 1; j--) {
			arrays[j + 1] = arrays[j];
		}
		arrays[j + 1] = arrays[0];
	}
}

空间复杂度：

$O(1)$

适用于顺序存储，因为使用了折半查找，所以不适用于链式存储

时间复杂度：

最坏时间复杂度：$O(n^2)$

平均时间复杂度：$O(n^2)$

希尔排序

对于直接插入排序，当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响；对其进行改进的一个方法就是希尔排序

希尔排序，又称为缩小增量排序，是不稳定的排序算法

基本思想：

先将排序表分割为 $d$ 个形如 L[i, i + d, i + 2d, ..., i + kd] 的特殊子表，分别进行直接插入排序，当整个表中的元素已经呈 基本有序时，再对全体记录进行依次直接插入排序

代码

• Python

def shell_sort(nums):
    gap = 1
    len_nums = len(nums)
    while gap < len_nums:
        gap = gap*3 + 1
    while gap > 0:
        for i in range(gap, len_nums):
            temp = nums[i]
            j = i-gap
            while j>=0 and nums[j]>temp:
                nums[j+gap] = nums[j]
                j -= gap
            nums[j+gap] = temp
        gap = gap//3
    return nums

• Java

package data.structure.sort;

import java.util.Arrays;
public class ShellSortDemo {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
//        shellSort(arr);
        shellSort2(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] arr) {
        // 交换形式 shellSort
        for (int gap = arr.length / 2; gap > 0 ; gap /= 2) {
            int temp = 0;
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
    }

    public static void shellSort2(int[] arr) {
        // 移位形式 shellsort
        for (int gap = arr.length / 2; gap > 0 ; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        // 移动
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    // 当退出 while 后，就找到了 temp 的插入位置
                    arr[j] = temp;
                }
            }
        }
    }
}

空间复杂度：

$O(1)$

适用于顺序存储

时间复杂度：

最坏时间复杂度：$O(n^2)$

但是一般情况下，比直接插入排序速度快点

归并排序

是一个稳定的排序算法

基本思想：

归并排序（MERGE-SORT）是利用 归并 的思想实现的排序方法，该算法采用经典的 分治（divide-and-conquer） 策略（分治法将问题分(divide)成一些小的问题然后递归求解，而 治(conquer) 的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)

2 路归并排序示意图：

代码

• Python

def ms_sort(nums):
    len_nums = len(nums)
    if len_nums<2:
        return nums
    mid = len_nums//2
    left = nums[0:mid]
    right = nums[mid:len_nums]
    return ms_merge(ms_sort(left), ms_sort(right))
    
def ms_merge(left, right):
    len_l = len(left)
    len_r = len(right)
    result = [0 for i in range(len_l + len_r)]
    i = 0
    while len_l>0 and len_r>0:
        if left[0]<=right[0]:
            result[i] = left[0]
            i += 1
            left = left[1:len_l]
            len_l = len(left)
        else:
            result[i] = right[0]
            i += 1
            right = right[1:len_r]
            len_r = len(right)
    while len_l > 0:
        result[i] = left[0]
        i += 1
        left = left[1:len_l]
        len_l = len(left)
    while len_r > 0:
        result[i] = right[0]
        i += 1
        right = right[1:len_r]
        len_r = len(right)
    return result

• Java

package data.structure.sort;
import java.lang.reflect.Array;
import java.util.Arrays;
public class MergeSortDemo {
    public static void main(String[] args) {
        int[] arr = {8, 4, 5, 7, 1, 3, 6, 2, 9, 0, 29};
        int[] temp = new int[arr.length];
        mergerSort(arr, 0, arr.length - 1, temp);
        System.out.println(Arrays.toString(arr));
    }

    // 分解过程
    public static void mergerSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergerSort(arr, left, mid, temp);
            mergerSort(arr, mid + 1, right, temp);
            merge(arr, left, mid, right, temp);
        }
    }

    // 合并过程
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;  // 表示左边有序序列的初始索引
        int j = mid + 1;  // 表示右边有序序列的初始索引
        int t = 0;     // 指向 temp 的当前索引
        // 先把左右两边有序的数据按照规则填充到 temp 中
        // 直到左右两边的有序序列，有一边处理完毕
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else {
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }
        // 把剩余的一个序列，全部填充到 temp
        while (i <= mid) {
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while (j <= right) {
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }
        // 把 temp 复制到 arr
        // 并不是每次都拷贝所有的数据
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }
    }
}

空间复杂度：

$O(n)$

既适用于顺序存储，也适用于链式存储

时间复杂度：

时间复杂度：$O(n\times {\log }_{2}n)$

计数排序

代码

• Python

def cs_sort(nums):
    max_value = get_max_value(nums)
    return counting_sort(nums, max_value)
def counting_sort(nums, max_value):
    bucket_len = max_value + 1
    bucket = [0 for i in range(bucket_len)]
    for i in nums:
        bucket[i] += 1
    sorted_index = 0
    for i in range(bucket_len):
        while bucket[i]>0:
            nums[sorted_index] = i
            sorted_index += 1
            bucket[i] -= 1
    return nums
def get_max_value(nums):
    max_value = nums[0]
    for i in nums:
        if max_value < i:
            max_value = i
    return max_value

桶排序

代码

• Python

def bucket_sort(nums, bucket_size):
    if len(nums) == 0:
        return nums
    min_value = nums[0]
    max_value = nums[0]
    for value in nums:
        if value < min_value:
            min_value = value
        elif value > max_value:
            max_value = value
    bucket_count = (max_value - min_value)//2 + 1
    buckets = [[] for _ in range(bucket_count)]
    for i in range(len(nums)):
        index = (nums[i] - min_value)//bucket_size
        buckets[index].append(nums[i])

    nums_index = 0
    for bucket in buckets:
        s = len(bucket)
        if len(bucket) <= 0:
            continue
    # 对每个桶使用插入排序
        is_bucket = insert_sort(bucket)
        for value in is_bucket:
            nums[nums_index] = value
            nums_index += 1
    return nums

基数排序

以上的排序方法都是基于移动和比较的排序方法，而基数排序是不基于比较的排序方法

它通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用

是一个稳定排序算法

借助 分配 和 收集 两种操作对单逻辑关键字进行排序，分为最高位优先（MSD）和最低位优先（LSD）

以 r 为基数的最低位优先基数排序的过程：

• 假设线性表由节点序列 $a_0,a_1,...,a_{n-1}$ 构成
• 每个节点 $a_j$ 的关键字由 $d$ 元组（$k_j^{d-1},k_j^{d-2},k_j^{d-3},...,k_j^1,k_j^0$）组成（$0\le k_j^i\le r-1(0\le j<n,0\le i\le d-1)$）

分配与收集：

• 在排序时使用 $r$ 个队列 $Q_0,Q_1,...,Q_{r-1}$
• 分配：开始时，把 $Q_0,Q_1,...,Q_{r-1}$ 各个队列置空，然后依次考察每一个节点的关键字，若 $a_j$ 的关键字中 $k_j^i=k$，就把 $a_j$ 放入队列 $Q_k$ 当中
• 收集：把 $Q_0,Q_1,...,Q_{r-1}$ 各个队列中的节点依次收尾相接，得到一个新的节点序列，组成线性表

$d$ 次分配收集后，序列就会排成有序的序列

空间复杂度：

$O(r)$

基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError

时间复杂度：

时间复杂度：$O(d\times (n+r))$

代码

• Python

def rs_sort(nums):
    max_digit = get_max_digit(nums)
    return radix_sort(nums, max_digit)
def get_max_digit(nums):
    '''get the highest bit'''
    max_value = get_max_value(nums)
    return get_num_length(max_value)
def get_max_value(nums):
    max_value = nums[0]
    for i in nums:
        if max_value < i:
            max_value = i
    return max_value
def get_num_length(num):
    if num == 0:
        return 1
    length = 0
    temp = num
    while (temp != 0):
        length += 1
        temp //= 10
    return length
def radix_sort(nums, max_digit):
    mod = 10
    dev = 1
    for i in range(max_digit):
        # [0-9] corresponds to negative, [10-19] corresponds to positive
        counter = [[] for _ in range(mod*2)]
        for j in range(len(nums)):
            bucket = ((nums[j] % mod) // dev) + mod
            counter[bucket].append(nums[j])
        pos = 0
        for bucket in counter:
            for value in bucket:
                nums[pos] = value
                pos += 1
        dev *= 10
        mod *= 10
    return nums

• Java

package data.structure.sort;

import java.util.Arrays;

public class radixSortDemo {
    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void radixSort(int[] arr) {
        // 使用空间换时间
        // 为了防止数据溢出，10个一维数组表示10个桶
        // 每个桶的大小设置为 arr.length
        int[][] bucket = new int[10][arr.length];
        // 定义一个一维数组，表示每个桶的放入数据数量
        int[] bucketEleCounts = new int[10];

        // 得到数组中最大数的位数
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        int maxLen = (max + "").length();
        for (int i = 0, n = 1; i < maxLen; i++, n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                // 取出每个数据的个位、十位、百位。。。
                int digitOfEle = arr[j] / n % 10;
                bucket[digitOfEle][bucketEleCounts[digitOfEle]] = arr[j];
                bucketEleCounts[digitOfEle] += 1;
            }
            // 按照桶中的顺序，重新放入原来的数组
            int index = 0;
            for (int k = 0; k < bucketEleCounts.length; k++) {
                // 如果桶中有数据，才放入数组中
                if (bucketEleCounts[k] != 0) {
                    // 循环第 k 个桶
                    for (int m = 0; m < bucketEleCounts[k]; m++) {
                        arr[index] = bucket[k][m];
                        index += 1;
                    }
                }
                bucketEleCounts[k] = 0;
            }
        }
    }
}

内部排序比较与应用

比较

排序算法	空间复杂度	最好时间复杂度	平均时间复杂度	最坏时间复杂度	稳定性
直接插入排序	$O(1)$	$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({\log }_2)$	$O(n\times {\log }_{2}n)$	$O(n\times {\log }_{2}n)$	$O(n^2)$	不稳定
堆排序	$O(1)$	$O(n\times {\log }_{2}n)$	$O(n\times {\log }_{2}n)$	$O(n\times {\log }_{2}n)$	不稳定
2路归并排序	$O(n)$	$O(n\times {\log }_{2}n)$	$O(n\times {\log }_{2}n)$	$O(n\times {\log }_{2}n)$	稳定
基数排序	$O(r)$	$O(d\times (n+r))$	$O(d\times (n+r))$	$O(d\times (n+r))$	稳定

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
• 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
• 内排序：所有排序操作都在内存中完成；
• 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
• 时间复杂度： 一个算法执行所耗费的时间。
• 空间复杂度：运行完一个程序所需内存的大小。
• n: 数据规模
• k: “桶”的个数
• In-place: 不占用额外内存
• Out-place: 占用额外内存

应用

考虑因素：

元素数目、元素大小、关键字结构及分布、稳定性、存储结构、辅助空间等

1. 若 $n$ 较小时（$n\le 50$），可以采用直接插入排序或者简单选择排序
2. 若 $n$ 较大时，则可以采用快排、堆排或者归并排序
3. 若 $n$ 很大，记录关键字位数比较少且可以分解，可以采用基数排序
4. 当文件的 $n$ 个关键字随机分布时，任何借助于 “比较” 的排序，至少需要 $O(n\times {\log }_{2}n)$ 的时间
5. 若初始基本有序，可以采用直接插入或者冒泡排序
6. 当记录元素比较大，应该避免大量移动的排序算法，尽量采用链式存储

外部排序

外部排序通常采用归并排序方法

首先，根据缓冲区的大小将外存上含有 $n$ 记录的文件分成若干长度为 $h$ 的子文件，依次读入内存并利用有限的内部排序算法对他们进行排序，并将排序后得到的有序子文件重新写回外存，通常称这些有序子文件为 归并段或者顺串

然后，对这些归并段进行逐趟归并，使归并段逐渐由小到大直至得到整个有序文件

$$外部排序的总时间=内部排序所需时间+外存信息读写时间+内部归并所需时间$$

失败树

树形选择排序的一种变体，可视为一棵完全二叉树

每个叶节点存放各归并段在归并过程中当前参加比较的记录，内部节点用来记忆左右字数中的 “失败者” ，胜利者向上继续进行比较，直到根节点

置换-选择排序

设初始待排序文件为 FI，初始归并段文件为 FO，内存工作区为 WA，内存工作区可以容纳 w 个记录

算法思想：

1. 从待排序文件 FI 输入 w 个记录到工作区 WA
2. 从内存工作区 WA 中选出其中关键字取最小值的记录，记为 MINIMAX
3. 将 MINIMAX 记录输出到 FO 中
4. 若 FI 未读完，则从 FI 输入下一个记录到 WA 中
5. 从 WA 中所有关键字比 MINIMAX 记录的关键字大的记录中选出最小的关键字记录，作为新的 MINIMAX
6. 重复 3~5 ，直到 WA 中选不出新的 MINIMAX 记录位置，由此得到一个初始归并段，输出一个归并段的结束标志到 FO 中

最佳归并树

m 路归并排序可以用一棵 m 叉树描述

归并树：
用来描述 m 归并，并只有度为 0 和度为 m 的节点的严格 m 叉树

带权路径长度之和为归并过程中的总读记录数

根据哈夫曼树的构造方式，

当叶子节点数不够时，增加权值为 0 的节点用来构造哈夫曼树

补充的虚段的个数：

设度为 $0$ 的节点有 $n_0$ 个，度为 $m$ 的节点有 $n_m$ 个

则对严格 $m$ 叉树有 $n_0=(m-1)\times n_m+1$，即得 $n_m=(n_0-1)/(m-1)$

• 若对 $(n_0-1)$，则说明对于这个 $n_0$ 个叶节点（初始归并段）可以构造 $m$ 叉树归并树
• 若对 $(n_0-1)$，则说明对于这个 $n_0$ 个叶节点（初始归并段）其中有 $u$ 个叶节点是多余的
• 多出 $u$ 个节点，则需要补充 $m-u-1$ 个节点