在计算机科学与数学中，一个排序算法（英语：Sorting algorithm）是一种能将一串资料依照特定排序方式排列的算法，排序后的资料即可放在有序数组。最常用到的排序方式是数值顺序以及字典顺序。有效的排序算法在一些算法（例如搜索算法与合并算法）中是重要的，如此这些算法才能得到正确解答。排序算法也用在处理文字资料以及产生人类可读的输出结果。基本上，排序算法的输出必须遵守下列两个原则：
- 输出结果为递增序列（递增是针对所需的排序顺序而言）
- 输出结果是原输入的一种排列、或是重组
虽然排序算法是一个简单的问题，但是从计算机科学发展以来，在此问题上已经有大量的研究。举例而言，冒泡排序在1956年就已经被研究。虽然大部分人认为这是一个已经被解决的问题，有用的新算法仍在不断的被发明。
冒泡排序 (Bubble Sort)
冒泡排序是一种简单的排序算法。它重复地遍历要排序的序列，依次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历序列的工作是重复地进行直到没有再需要交换为止，此时说明该序列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢 "浮" 到数列的顶端。
算法步骤
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤 1~3，直到排序完成。
图解算法：
public class BubbleSortTest {
/**
* 冒泡排序
*/
public static int[] bubbleSort(int[] arr){
for (int i=1;i< arr.length;i++){
boolean flag = true;
for (int j = 0; j< arr.length-i;j++){
if (arr[j] > arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j + 1] = tmp;
flag = false;
}
}
if (flag){
break;
}
}
return arr;
}
public static void main(String[] args) {
int[] a = {12,23,45,67,89,21,22,11,10};
int[] a1 = bubbleSort(a);
System.out.println("a1:"+ Arrays.toString(a1));
System.out.println(Arrays.stream(a1).max());
}
}选择排序 (Selection Sort)
选择排序是一种简单直观的排序算法，无论什么数据进去都是O(n²)的时间复杂度。所以用到它的时候，数据规模越小越好。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
算法步骤:
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
- 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
- 重复第2步，直到所有元素均排序完毕。
public class SelectionSort {
/**
* 选择排序
*/
public static int[] selectionSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
return arr;
}
public static void main(String[] args) {
int[] arr = {5, 4, 3, 2, 1, 6, 10, 3, 1};
System.out.print("选择排序前:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
int[] result = selectionSort(arr);
System.out.print("\n选择排序结果:");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i] + " ");
}
}
}插入排序(Insertion Sort)
插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序也有一种优化算法，叫做拆半插入。
**直接插入排序：**在已排序序列中使用线性查找（从后往前一个一个比）来寻找插入位置。
折半插入排序 **：**在已排序序列中使用二分查找来快速定位插入位置。
算法步骤
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
public class InsertionSortTest {
/**
* 直接插入排序
*/
public static int[] insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int preIndex = i - 1;
int current = arr[i];
// 从后往前比较，如果前一个元素大于当前元素，则将前一个元素向后移动一位，直到找到当前元素该插入的位置
while (preIndex >= 0 && arr[preIndex] > current) {
// 将 preIndex 的元素向后移动一位
arr[preIndex + 1] = arr[preIndex];
preIndex--;
}
arr[preIndex + 1] = current;
}
return arr;
}
/**
* 折半插入排序（二分插入排序）
* 时间复杂度：O(n²) 但比较次数只有 O(n log n)，比直接插入少很多比较
* 空间复杂度：O(1)
* 稳定排序
*/
public static void binaryInsertionSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
// 从第2个元素开始处理
for (int i = 1; i < arr.length; i++) {
int temp = arr[i]; // 要插入的元素（先保存，防止被覆盖）
int low = 0; // 已排序区的左边界
int high = i - 1; // 已排序区的右边界
// 二分查找插入位置（找第一个 >= temp 的位置，或者说最后一个 < temp 的位置的后面）
while (low <= high) {
int mid = low + (high - low) / 2; // 防止溢出写法（推荐）
if (arr[mid] > temp) {
high = mid - 1; // temp 应该插在 mid 左边
} else {
low = mid + 1; // temp 应该插在 mid 右边（包括等于的情况，也往右找，保持稳定性）
}
}
// 循环结束时，low 就是插入位置（high 会变成 low-1）
// 将 [low, i-1] 的元素整体右移一位，给 temp 腾位置
for (int j = i - 1; j >= low; j--) {
arr[j + 1] = arr[j];
}
// 把 temp 放到正确位置
arr[low] = temp;
}
}
public static void main(String[] args) {
int[] arr = {5, 3, 2, 1, 4, 6, 10, 3, 1};
System.out.print("插入排序前:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
int[] result = insertionSort(arr);
System.out.print("\n插入排序结果:");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i] + " ");
}
int[] arr1 = {5, 3, 2, 1, 4, 6, 10, 3, 1};
System.out.print("\n折半插入排序前:");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + " ");
}
binaryInsertionSort(arr1);
System.out.print("\n折半插入排序结果:");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + " ");
}
}
}希尔排序(Shell Sort)
希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为递减增量排序算法，同时该算法是冲破O(n²)的第一批算法之一。
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
算法步骤
我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2, (n/2)/2, ..., 1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列{t1, t2, ..., tk}，其中(ti>tj, i<j, tk=1)；
- 按增量序列个数k，对序列进行k趟排序；
- 每趟排序，根据对应的增量t，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1时，整个序列作为一个表来处理，表长度即为整个序列的长度。
public class ShellSortTest {
/**
* 希尔排序算法实现
*
* @param arr 待排序的整数数组
* @return 排序后的整数数组
*/
public static int[] shellSort(int[] arr) {
int n = arr.length;
int gap = n / 2;
// 希尔排序主循环，逐步缩小间隔
while (gap > 0) {
// 对每个间隔组进行插入排序
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j = i - gap;
// 在当前间隔组内进行插入排序
while (j >= 0 && arr[j] > temp) {
arr[j + gap] = arr[j];
j -= gap;
}
arr[j + gap] = temp;
}
// 缩小间隔，继续下一轮排序
gap /= 2;
}
return arr;
}
public static void main(String[] args) {
int[] arr = {5, 4, 3, 2, 1, 6, 10, 3, 1};
System.out.print("希尔排序前:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
int[] result = shellSort(arr);
System.out.print("\n希尔排序结果:");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i] + " ");
}
}
}归并排序(Merge Sort)
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn)的时间复杂度。代价是需要额外的内存空间。
算法步骤
归并排序算法是一个递归过程，边界条件为当输入序列仅有一个元素时，直接返回，具体过程如下：
- 如果输入内只有一个元素，则直接返回，否则将长度为n的输入序列分成两个长度为n/2的子序列；
- 分别对这两个子序列进行归并排序，使子序列变为有序状态；
- 设定两个指针，分别指向两个已经排序子序列的起始位置；
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间（用于存放排序结果），并移动指针到下一位置；
- 重复步骤3 ~4直到某一指针达到序列尾；
- 将另一序列剩下的所有元素直接复制到合并序列尾。
public class MergeSortTest {
/**
* 归并排序主函数，将数组递归分解并排序
*
* @param arr 待排序的整数数组
* @return 排序后的整数数组
*/
public static int[] MergeSort(int[] arr) {
// 递归终止条件：数组长度小于等于1时直接返回
if (arr.length <= 1) {
return arr;
}
// 将数组从中间分割成两部分
int middle = arr.length / 2;
int[] arr_1 = Arrays.copyOfRange(arr, 0, middle);
int[] arr_2 = Arrays.copyOfRange(arr, middle, arr.length);
// 递归排序两个子数组并合并
return Merge(MergeSort(arr_1), MergeSort(arr_2));
}
/**
* 合并两个已排序的数组
*
* @param arr_1 第一个已排序的数组
* @param arr_2 第二个已排序的数组
* @return sorted_arr 合并后的已排序数组
*/
public static int[] Merge(int[] arr_1, int[] arr_2) {
// 创建结果数组，长度为两个输入数组长度之和
int[] sorted_arr = new int[arr_1.length + arr_2.length];
int idx = 0, idx_1 = 0, idx_2 = 0;
// 比较两个数组元素，按顺序合并到结果数组中
while (idx_1 < arr_1.length && idx_2 < arr_2.length) {
if (arr_1[idx_1] < arr_2[idx_2]) {
sorted_arr[idx] = arr_1[idx_1];
idx_1 += 1;
} else {
sorted_arr[idx] = arr_2[idx_2];
idx_2 += 1;
}
idx += 1;
}
// 将剩余元素复制到结果数组中
if (idx_1 < arr_1.length) {
while (idx_1 < arr_1.length) {
sorted_arr[idx] = arr_1[idx_1];
idx_1 += 1;
idx += 1;
}
} else {
while (idx_2 < arr_2.length) {
sorted_arr[idx] = arr_2[idx_2];
idx_2 += 1;
idx += 1;
}
}
return sorted_arr;
}
public static void main(String[] args) {
int[] arr = {5, 4, 3, 2, 1, 6, 10, 3, 1};
System.out.print("归并排序前:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
int[] result = MergeSort(arr);
System.out.print("\n归并排序结果:");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i] + " ");
}
}
}快速排序(Quick Sort)
快速排序用到了分治思想，同样的还有归并排序。乍看起来快速排序和归并排序非常相似，都是将问题变小，先排序子串，最后合并。不同的是快速排序在划分子问题的时候经过多一步处理，将划分的两组数据划分为一大一小，这样在最后合并的时候就不必像归并排序那样再进行比较。但也正因为如此，划分的不定性使得快速排序的时间复杂度并不稳定。
快速排序的基本思想：通过一趟排序将待排序列分隔成独立的两部分，其中一部分记录的元素均比另一部分的元素小，则可分别对这两部分子序列继续进行排序，以达到整个序列有序。
算法步骤
快速排序使用分治法（Divide and conquer）策略来把一个序列分为较小和较大的2个子序列，然后递回地排序两个子序列。具体算法描述如下：
- 从序列中随机挑出一个元素，做为 "基准"(pivot)；
- 重新排列序列，将所有比基准值小的元素摆放在基准前面，所有比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个操作结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地把小于基准值元素的子序列和大于基准值元素的子序列进行快速排序。
public class QuickSortTest {
/**
* 交换数组中两个位置的元素
*
* @param arr 要操作的数组
* @param i 第一个元素的下标
* @param j 第二个元素的下标
*/
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i]; // 临时保存 arr[i] 的值
arr[i] = arr[j]; // 将 arr[j] 的值赋给 arr[i]
arr[j] = tmp; // 将保存的原 arr[i] 值赋给 arr[j]
}
/**
* 划分函数（Partition）：将数组 arr[left...right] 划分为两部分
* 使得左边部分都小于等于 pivot，右边部分都大于等于 pivot
*
* @param arr 待排序数组
* @param left 当前区间的左边界（包含）
* @param right 当前区间的右边界（包含）
* @return 划分完成后 pivot（基准值）最终所在的位置下标
*/
private static int Partition(int[] arr, int left, int right) {
// 如果区间只有一个元素，直接返回（防止后续随机时出错）
if (left == right) {
return left;
}
// 随机选择一个基准值（pivot），并将其交换到数组最右端
// 随机化可以有效避免最坏情况（已排序或逆序时退化为 O(n²)）
int pivot = left + (int) (Math.random() * (right - left + 1));
swap(arr, pivot, right); // 把随机选中的元素放到最右端作为基准
int small_idx = left; // small_idx 指向「小于区」的下一个位置（即大于等于区的起始）
// 从 left 开始遍历到 right-1（right 位置是基准，不参与比较）
for (int i = left; i < right; i++) {
if (arr[i] < arr[right]) { // 如果当前元素小于基准值
swap(arr, i, small_idx); // 将它交换到「小于区」的末尾
small_idx++; // 小于区向右扩张一位
}
// 如果 arr[i] >= arr[right]，什么都不做，留在原地（属于大于等于区）
}
// 最后把基准值放到「小于区」和「大于等于区」的分界线上
swap(arr, small_idx, right);
return small_idx; // 返回基准值最终的位置
}
/**
* 快速排序主函数（递归实现）
*
* @param arr 待排序的整数数组
* @param left 待排序区间的左边界（包含）
* @param right 待排序区间的右边界（包含）
* @return 返回排好序的原数组（就地排序）
*/
public static int[] QuickSort(int[] arr, int left, int right) {
// 当 left >= right 时，区间中只有 0 或 1 个元素，无需排序（递归终止条件）
if (left < right) {
int pivotIndex = Partition(arr, left, right); // 进行一次划分，得到基准位置
// 递归处理基准左边的子区间
QuickSort(arr, left, pivotIndex - 1);
// 递归处理基准右边的子区间
QuickSort(arr, pivotIndex + 1, right);
}
return arr; // 排序完成后返回原数组
}
public static void main(String[] args) {
int[] arr = {5, 4, 3, 2, 1, 6, 10, 3, 1};
System.out.print("快速排序前:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
int[] result = QuickSort(arr, 0, arr.length - 1);
System.out.print("\n快速排序结果:");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i] + " ");
}
}
}堆排序(Heap Sort)
堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子结点的值总是小于（或者大于）它的父节点。
算法步骤
- 将初始待排序列(R1, R2, ......, Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1, R2, ......, Rn-1)和新的有序区(Rn),且满足R[1, 2, ......, n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1, R2, ......, Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1, R2, ......, Rn-2)和新的有序区(Rn-1, Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
public class HeapSortTest {
// 全局变量：记录当前「堆」的有效长度（已排序的部分不属于堆）
// 在排序过程中，堆的范围会从 arr[0...heapLen-1] 逐渐缩小
static int heapLen;
/**
* 交换数组中两个位置的元素
*
* @param arr 待操作的数组
* @param i 下标 i
* @ @param j 下标 j
*/
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
/**
* 构建最大堆（大顶堆）
* 从最后一个非叶子结点开始，依次向前进行下沉调整
*
* @param arr 待构建的数组
*/
private static void buildMaxHeap(int[] arr) {
heapLen = arr.length; // 初始时整个数组都属于堆
// arr.length/2 - 1 是完全二叉树中最后一个非叶子结点的下标
// 从这个结点开始向前遍历，所有非叶子结点都要执行 heapify
for (int i = arr.length / 2 - 1; i >= 0; i--) {
heapify(arr, i);
}
}
/**
* 堆调整（下沉）：让以 i 为根的子树重新满足大顶堆性质
*
* @param arr 数组
* @param i 需要下沉的结点下标（根结点）
*/
private static void heapify(int[] arr, int i) {
int left = 2 * i + 1; // 左孩子下标
int right = 2 * i + 2; // 右孩子下标
int largest = i; // 记录当前子树中值最大的结点下标，初始为根
// 如果右孩子在堆的有效范围内，且右孩子的值更大，则更新 largest
if (right < heapLen && arr[right] > arr[largest]) {
largest = right;
}
// 如果左孩子在堆的有效范围内，且左孩子的值更大，则更新 largest
if (left < heapLen && arr[left] > arr[largest]) {
largest = left;
}
// 如果子结点中有更大的值，则需要交换并继续向下调整
if (largest != i) {
swap(arr, i, largest); // 根结点与更大的孩子交换
heapify(arr, largest); // 递归地对受影响的子树继续下沉
}
// 如果 largest == i，说明当前子树已经满足大顶堆性质，直接返回
}
/**
* 堆排序主函数（升序，使用大顶堆实现）
* 核心思想：
* 1. 先把整个数组建成一个大顶堆
* 2. 每次把堆顶（当前最大值）放到已排序区间的末尾
* 3. 缩小堆的大小，重新调整堆顶
*
* @param arr 待排序的整数数组
* @return 排好序的原数组（就地排序）
*/
public static int[] HeapSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return arr;
}
heapLen = arr.length; // 初始化堆的长度为整个数组
buildMaxHeap(arr); // 第一步：构建初始大顶堆
// 从数组最后一个元素开始，逐步将最大值放到对应位置
for (int i = arr.length - 1; i > 0; i--) {
// 将当前堆顶（最大值）与当前未排序部分的最后一个元素交换
// 交换后，最大值就放到了正确位置（已排序区）
swap(arr, 0, i);
heapLen -= 1; // 已排序区域增大，堆的有效长度减1
// 由于交换后堆顶可能不再是最大值，需要重新调整堆（从根开始下沉）
heapify(arr, 0);
}
return arr; // 返回排好序的数组
}
public static void main(String[] args) {
int[] arr = {5, 4, 3, 2, 1, 6, 10, 3, 1};
System.out.print("堆排序前:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
int[] result = HeapSort(arr);
System.out.print("\n堆排序结果:");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i] + " ");
}
}
}计数排序(Counting Sort)
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。
算法步骤
- 找出数组中的最大值max、最小值min；
- 创建一个新数组C，其长度是max-min+1，其元素默认值都为0；
- 遍历原数组A中的元素A[i]，以A[i]-min作为C数组的索引，以A[i]的值在A中元素出现次数作为C[A[i]-min]的值；
- 对C数组变形，新元素的值是该元素与前一个元素值的和，即当i>1时C[i] = C[i] + C[i-1]；
- 创建结果数组R，长度和原始数组一样。
- 从后向前遍历原始数组A中的元素A[i]，使用A[i]减去最小值min作为索引，在计数数组C中找到对应的值C[A[i]-min]，C[A[i]-min]-1就是A[i]在结果数组R中的位置，做完上述这些操作，将count[A[i]-min]减小1。
public class CountingSortTest {
/**
* 找出数组中的最大值和最小值
*
* @param arr 输入数组（假设非空）
* @return 返回一个长度为 2 的数组：{最小值, 最大值}
*/
private static int[] getMinAndMax(int[] arr) {
int maxValue = arr[0]; // 初始假设第一个元素是最大值
int minValue = arr[0]; // 初始假设第一个元素是最小值
// 遍历整个数组，更新最大值和最小值
for (int i = 0; i < arr.length; i++) {
if (arr[i] > maxValue) { // 如果当前元素更大，更新最大值
maxValue = arr[i];
} else if (arr[i] < minValue) { // 如果当前元素更小，更新最小值
minValue = arr[i];
}
}
// 返回 {min, max}，方便后面计算计数数组的大小
return new int[]{minValue, maxValue};
}
/**
* 计数排序（稳定版，支持负数）
* 适用于：数值范围不大、包含负数的整数数组排序
* <p>
* 时间复杂度：O(n + k) 其中 k = max - min + 1
* 空间复杂度：O(n + k)
* 稳定性：稳定（相同元素相对顺序不变）
*
* @param arr 待排序的整数数组
* @return 排好序的新数组（原数组不变）
*/
public static int[] CountingSort(int[] arr) {
// 长度小于 2 的数组已经有序，直接返回
if (arr == null || arr.length < 2) {
return arr;
}
// 第一步：找出数组的最大值和最小值
int[] extremum = getMinAndMax(arr);
int minValue = extremum[0];
int maxValue = extremum[1];
// 第二步：创建计数数组
// 大小为 (max - min + 1)，能把所有数值映射到非负下标
// 例如：[-5, -3, 0, 2] → min=-5 → countArr[0] 表示 -5，countArr[7] 表示 2
int[] countArr = new int[maxValue - minValue + 1];
// 第三步：统计每个数字出现的次数
for (int i = 0; i < arr.length; i++) {
// 将原值 arr[i] 映射为 countArr 的下标：arr[i] - minValue
countArr[arr[i] - minValue] += 1;
}
// 第四步：将计数数组变形为"累加数组"
// 变形后：countArr[i] 表示"小于等于当前值的元素总个数"
for (int i = 1; i < countArr.length; i++) {
countArr[i] += countArr[i - 1];
}
// 第五步：从后向前遍历原数组，确定每个元素应该放在结果数组的哪个位置
// 必须从后向前遍历，才能保证排序的稳定性！
int[] result = new int[arr.length];
for (int i = arr.length - 1; i >= 0; i--) {
// 计算当前元素应该放在结果数组的哪个下标
int mappedIndex = arr[i] - minValue; // 映射到 countArr 的下标
int position = countArr[mappedIndex] - 1; // 应该放的位置（从0开始）
result[position] = arr[i]; // 放到正确位置
countArr[mappedIndex] -= 1; // 该位置已用，下次同值元素放在前一个位置
}
// 返回排序好的新数组
return result;
}
public static void main(String[] args) {
int[] arr = {5, 4, 3, 2, 1, 6, 10, 3, 1};
System.out.print("计数排序前:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
int[] result = CountingSort(arr);
System.out.print("\n计数排序结果:");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i] + " ");
}
}
}桶排序(Bucket Sort)
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：
- 在额外空间充足的情况下，尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
桶排序的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行。
算法步骤
- 设置一个BucketSize，作为每个桶所能放置多少个不同数值；
- 遍历输入数据，并且把数据依次映射到对应的桶里去；
- 对每个非空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
- 从非空桶里把排好序的数据拼接起来。
public class BucketSortTest {
/**
* 找出 List<Integer> 中的最小值和最大值
*
* @param arr 非空整数列表
* @return int[] {最小值, 最大值}
*/
private static int[] getMinAndMax(List<Integer> arr) {
int maxValue = arr.get(0); // 假设第一个元素是最大值
int minValue = arr.get(0); // 假设第一个元素是最小值
// 遍历所有元素，实时更新极值
for (int value : arr) {
if (value > maxValue) {
maxValue = value; // 发现更大的值，更新最大值
} else if (value < minValue) {
minValue = value; // 发现更小的值，更新最小值
}
}
return new int[] { minValue, maxValue };
}
/**
* 插入排序（专门用于小规模数据或单个桶内排序）
* 简单、稳定、对于少量元素性能极佳（优于递归开销）
*
* @param arr 待排序的列表
* @return 排好序的新列表
*/
private static List<Integer> insertionSort(List<Integer> arr) {
List<Integer> result = new ArrayList<>(arr); // 复制一份，避免修改原列表
// 从第二个元素开始，向前插入
for (int i = 1; i < result.size(); i++) {
int key = result.get(i); // 当前要插入的元素
int j = i - 1;
// 将比 key 大的元素全部后移一位
while (j >= 0 && result.get(j) > key) {
result.set(j + 1, result.get(j));
j--;
}
// 找到正确位置，插入 key
result.set(j + 1, key);
}
return result;
}
/**
* 桶排序（生产级优化版）
*
* 特性亮点：
* 1. 支持负数（通过 minValue 偏移）
* 2. 自动降级为插入排序（小数据量更快）
* 3. 自适应桶大小（递归时减半，防止最坏情况）
* 4. 边界安全处理（越界、相等元素、桶大小为0）
* 5. 稳定性保持（桶内使用稳定排序）
*
* 时间复杂度：平均 O(n)，最坏 O(n²)，最佳 O(n)
* 空间复杂度：O(n)
*
* @param arr 待排序的整数列表
* @param bucket_size 每个桶预期容纳的元素个数（建议 5~20）
* @return 排好序的新列表（原列表不变）
*/
public static List<Integer> BucketSort(List<Integer> arr, int bucket_size) {
// 边界检查：空列表或只有一个元素，直接返回
if (arr == null || arr.size() < 2) {
return arr == null ? new ArrayList<>() : new ArrayList<>(arr);
}
// 如果桶大小非法，设置为默认值 5（经验最优）
if (bucket_size <= 0) {
bucket_size = 5;
}
// 小数据量直接用插入排序更快（避免递归和分配桶的开销）
if (arr.size() <= 10 || bucket_size == 1) {
return insertionSort(arr);
}
// 获取数值范围
int[] extremum = getMinAndMax(arr);
int minValue = extremum[0];
int maxValue = extremum[1];
// 特判：所有元素都相等，无需排序
if (minValue == maxValue) {
return new ArrayList<>(arr);
}
// 计算桶的数量：(max - min) / bucket_size + 1
int bucket_cnt = (maxValue - minValue) / bucket_size + 1;
// 创建 bucket_cnt 个空桶，每个桶是一个 ArrayList
List<List<Integer>> buckets = new ArrayList<>();
for (int i = 0; i < bucket_cnt; i++) {
buckets.add(new ArrayList<Integer>());
}
// 将每个元素分配到对应的桶中
for (int element : arr) {
int bucketIndex = (element - minValue) / bucket_size;
// 防止数值恰好等于 maxValue 时越界（数学上可能 bucketIndex == bucket_cnt）
if (bucketIndex >= bucket_cnt) {
bucketIndex = bucket_cnt - 1;
}
buckets.get(bucketIndex).add(element);
}
// 对每个非空桶进行排序
for (int i = 0; i < buckets.size(); i++) {
List<Integer> bucket = buckets.get(i);
if (bucket.size() > 1) {
// 递归排序当前桶，桶大小减半（关键优化！防止退化成 O(n²)）
int newBucketSize = Math.max(1, bucket_size / 2);
buckets.set(i, BucketSort(bucket, newBucketSize));
}
// 如果桶内只有 0 或 1 个元素，无需排序
}
// 按顺序合并所有桶，得到最终有序结果
ArrayList<Integer> result = new ArrayList<>();
for (List<Integer> bucket : buckets) {
result.addAll(bucket);
}
return result;
}
public static void main(String[] args) {
Integer[] arr = { 5, 4, 3, 2, 1, 6, 10, 3, 1 };
List<Integer> list = Arrays.asList(arr);
System.out.println("排序前的数组：" + list);
List<Integer> sortedList = BucketSort(list, 5);
System.out.println("排序后的数组：" + sortedList);
// 测试边界情况
System.out.println("空列表测试：" + BucketSort(new ArrayList<>(), 5));
System.out.println("单元素测试：" + BucketSort(Arrays.asList(1), 5));
}
}基数排序(Radix Sort)
基数排序也是非比较的排序算法，对元素中的每一位数字进行排序，从最低位开始排序，复杂度为O(n×k)，n为数组长度，k为数组中元素的最大的位数；
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
算法步骤
- 取得数组中的最大数，并取得位数，即为迭代次数N（例如：数组中最大数值为1000，则N=4）；
- A为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
- 将radix依次赋值给原数组；
- 重复2~4步骤N次
public class RadixSortTest {
/**
* 基数排序（LSD）------ 完整支持负数版（推荐！）
* 核心思想：
* 1. 把负数和非负数分开处理
* 2. 对绝对值使用标准的正数基数排序
* 3. 最后：倒序放回负数 + 正序放回正数
*
* 时间复杂度：O(d × n)
* 空间复杂度：O(n)
* 稳定性：稳定
*/
public static void RadixSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
// 第一步：分离正数和负数
List<Integer> negatives = new ArrayList<>();
List<Integer> nonNegatives = new ArrayList<>();
for (int num : arr) {
if (num < 0) {
negatives.add(-num); // 存绝对值，方便排序
} else {
nonNegatives.add(num);
}
}
// 第二步：分别对绝对值进行基数排序
int[] negArr = negatives.stream().mapToInt(i -> i).toArray();
int[] posArr = nonNegatives.stream().mapToInt(i -> i).toArray();
radixSortPositive(negArr); // 负数的绝对值排序
radixSortPositive(posArr); // 正数排序
// 第三步：合并结果（负数倒序 + 正数正序）
int index = 0;
// 先放负数（倒序，因为我们排的是绝对值，越大的绝对值应该越靠前）
for (int i = negArr.length - 1; i >= 0; i--) {
arr[index++] = -negArr[i];
}
// 再放正数（正序）
for (int num : posArr) {
arr[index++] = num;
}
}
// 标准的正数基数排序（只处理 >=0 的数）
private static void radixSortPositive(int[] arr) {
if (arr.length == 0) {
return;
}
// 找最大值，确定位数
int max = arr[0];
for (int num : arr) {
if (num > max) {
max = num;
}
}
// 从个位开始，一位一位排序
for (int exp = 1; max / exp > 0; exp *= 10) {
countingSortByDigit(arr, exp);
}
}
// 按某一位进行计数排序（稳定）
private static void countingSortByDigit(int[] arr, int exp) {
int n = arr.length;
int[] output = new int[n];
int[] count = new int[10];
// 统计当前位的数字出现次数
for (int i = 0; i < n; i++) {
int digit = (arr[i] / exp) % 10;
count[digit]++;
}
// 转化为"小于等于该数字的总数"
for (int i = 1; i < 10; i++) {
count[i] += count[i - 1];
}
// 从右向左填充（保证稳定性）
for (int i = n - 1; i >= 0; i--) {
int digit = (arr[i] / exp) % 10;
output[--count[digit]] = arr[i];
}
// 写回原数组
System.arraycopy(output, 0, arr, 0, n);
}
// ==================== 测试主函数 ====================
public static void main(String[] args) {
int[] arr = { 5, 4, 3, 2, 1, 6, 10, 3, 1, -1, -6, -10, -3, -1 };
System.out.print("排序前: ");
printArray(arr);
RadixSort(arr);
System.out.print("排序后: ");
printArray(arr);
}
private static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
}稳定的排序算法
冒泡排序 (Bubble Sort)
时间复杂度：平均 O(n²)，最坏 O(n²)，最好 O(n)
空间复杂度：O(1)
特点：简单实现，适合小数据集
插入排序 (Insertion Sort)
时间复杂度：平均 O(n²)，最坏 O(n²)，最好 O(n)
空间复杂度：O(1)
特点：对几乎有序的数据效率高
鸡尾酒排序 (Cocktail Sort)
时间复杂度：平均 O(n²)，最坏 O(n²)，最好 O(n)
空间复杂度：O(1)
特点：双向冒泡排序
桶排序 (Bucket Sort)
时间复杂度：平均 O(n)，最坏 O(n²)，最好 O(n)
空间复杂度：O(k)
特点：需要 O(k) 额外空间
计数排序 (Counting Sort)
时间复杂度：平均 O(n+k)，最坏 O(n+k)，最好 O(n+k)
空间复杂度：O(n+k)
特点：需要 O(n+k) 额外空间
归并排序 (Merge Sort)
时间复杂度：平均 O(n log n)，最坏 O(n log n)，最好 O(n log n)
空间复杂度：O(n)
特点：需要 O(n) 额外空间
原地归并排序
时间复杂度：平均 O(n log² n)
特点：如果使用最佳版本
二叉排序树排序 (Binary Tree Sort)
时间复杂度：平均 O(n log n)，最坏 O(n²)
空间复杂度：O(n)
特点：期望时间 O(n log n)，最坏时间 O(n²)
鸽巢排序 (Pigeonhole Sort)
时间复杂度：平均 O(n+k)，最坏 O(n+k)
空间复杂度：O(k)
特点：需要 O(k) 额外空间
基数排序 (Radix Sort)
时间复杂度：平均 O(nk)，最坏 O(nk)
空间复杂度：O(n)
特点：需要 O(n) 额外空间
侏儒排序 (Gnome Sort)
时间复杂度：平均 O(n²)，最坏 O(n²)
空间复杂度：O(1)
图书馆排序 (Library Sort)
时间复杂度：平均 O(n log n)，最坏 O(n²)
空间复杂度：O((1+ε)n)
特点：期望时间 O(n log n)，需要 (1+ε)n 额外空间
块排序 (Block Sort)
时间复杂度：平均 O(n log n)，最坏 O(n log n)
空间复杂度：O(1)
Tim排序 (Timsort)
时间复杂度：平均 O(n log n)，最坏 O(n log n)，最好 O(n)
空间复杂度：O(n)
特点：目前已知最快的排序算法，Python、Swift、Rust等语言的默认算法
不稳定的排序算法
选择排序 (Selection Sort)
时间复杂度：平均 O(n²)，最坏 O(n²)，最好 O(n²)
空间复杂度：O(1)
希尔排序 (Shell Sort)
时间复杂度：平均 O(n log² n)
空间复杂度：O(1)
特点：如果使用最佳版本
克洛弗排序 (Clover Sort)
时间复杂度：平均 O(n)，最坏 O(n²)
空间复杂度：O(1)
梳排序 (Comb Sort)
时间复杂度：平均 O(n log n)
空间复杂度：O(1)
堆排序 (Heap Sort)
时间复杂度：平均 O(n log n)，最坏 O(n log n)，最好 O(n log n)
空间复杂度：O(1)
平滑排序 (Smooth Sort)
时间复杂度：平均 O(n log n)，最坏 O(n log n)
空间复杂度：O(1)
快速排序 (Quick Sort)
时间复杂度：平均 O(n log n)，最坏 O(n²)，最好 O(n log n)
空间复杂度：O(log n)
内省排序 (Introsort)
时间复杂度：平均 O(n log n)，最坏 O(n log n)
空间复杂度：O(log n)
耐心排序 (Patience Sort)
时间复杂度：平均 O(n log n + k)，最坏 O(n log n + k)
空间复杂度：O(n + k)
特点：需要找到最长递增子序列
不实用的排序算法
Bogo排序
时间复杂度：平均 O(n × n!)，最坏期望时间为无穷
Stupid排序
时间复杂度：O(n³)
空间复杂度：递归版本需要 O(n²) 额外存储器
珠排序 (Bead Sort)
时间复杂度：O(n) 或 O(√n)
特点：需要特别的硬件
煎饼排序 (Pancake Sort)
时间复杂度：O(n)
特点：需要特别的硬件
臭皮匠排序 (Stooge Sort)
时间复杂度：约 O(n²·⁷)
特点：算法简单但效率极低