十大经典排序算法思想及代码详细讲解
术语说明
- 时间复杂度：一个算法执行所耗费的时间。
- 空间复杂度：一个算法执行所耗费的空间。
- 原地排序：在排序过程中只需要常数量空间进行排序(In-place)。
- 非原地排序：在排序过程中需要利用额外的数组来辅助排序(Out-place)。
- 比较排序：通过比较每一个数确定先后顺序，实现排序。
- 非比较排序：通过确定每个元素之前应该有多少个元素来排序。
- 稳定排序：如果两个元素相等且在排序前后相对位置不改变，则称排序是稳定的。
- 非稳定排序：如果两个元素相等且在排序前后相对位置可能改变，则称排序是不稳定的。
算法总结
01冒泡排序
算法简介
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，直到比较完所有的元素。
算法步骤
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，并排除已经比较完毕的元素。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
记忆要点
相邻元素比较，符合情况进行交换，每轮都会从头开始，每轮都会得到一个最大(小)值，并排除已经得到的最大值。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10，每一轮都会通过相邻比较并交换得到一个最大值且最终交换到数组最后。
代码展示
/**
* 冒泡排序算法: 相邻比较，如果第一个大于第二个就进行交换，每一轮得到一个最大值
* 要点：查找的同时进行交换，查找完毕交换完毕
*/
public class BubbleSort {
public int[] bubbleSort(int[] arr) {
//arr.length = 10 ,有9个相邻组，循环9次
for (int i = 1; i < arr.length; i++) {
//arr.length - i 每轮减去已经排好序的
for (int j = 0; j < arr.length - i; j++) {
//找最大值
if (arr[j] > arr[j + 1]) {
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
public static void main(String[] args) {
BubbleSort bubble = new BubbleSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = bubble.bubbleSort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
02选择排序
算法简介
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。
算法步骤
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
- 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
- 重复第二步，直到所有元素均排序完毕。
记忆要点
每轮找最小值，最后交换已排序末尾索引。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10，每一轮都会通过比较得到一个最小值索引且最终交换所以你对应值到数组最前面。
代码展示
/**
* 选择排序算法: 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
* 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾，重复至此。
* 要点：先查找，最后交换
*/
public class SelectionSort {
public int[] selectionSort(int[] arr) {
// 总共要经过 N-1 轮比较
for (int i = 0; i < arr.length - 1; i++) {
//记录每轮最小位置的索引
int min = i;
// 每轮需要比较的次数 N-i
for (int j = i + 1; j < arr.length; j++) {
//找到本轮中最小值索引
if (arr[j] < arr[min]) {
min = j;
}
}
//i始终是arr数组中已排序的末尾位置，交换索引位置
if (i != min) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
return arr;
}
public static void main(String[] args) {
SelectionSort selection = new SelectionSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = selection.selectionSort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
03插入排序
算法简介
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在==已排序序列中从后向前扫描，找到相应位置并插入。==插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。
算法步骤
- 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
- 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。
- 如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。
记忆要点
与已经排完序的序列倒着比较，小于已排序元素则将已排序元素后移一位，找到合适位置插入。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10，每一轮已排序序列都会增加一位，未排序都会减少一位。
代码展示
/**
* 插入排序算法：将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
* 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
* 要点：比对已排序，大于插入元素的往后挪
*/
public class InsertionSort {
public int[] insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int temp = arr[i];
int j = i;
//从小到大排序
while (j > 0 && temp < arr[j - 1]) {
//与已经排完序的序列倒着比较，小于则将前一个后移（因为temp保存这当前，不怕被覆盖）
arr[j] = arr[j - 1];
j--;
}
//将temp插入到合适位置
if (j != i) {
arr[j] = temp;
}
}
return arr;
}
public static void main(String[] args) {
InsertionSort insertion = new InsertionSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = insertion.insertionSort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
04希尔排序
算法简介
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
算法步骤
- 首先确定步长及步长的变化，从而确定最外层循环的次数。
- 从每一个步长开始，依次比较相隔该步长的两个元素，如果该元素满足条件，将当前元素覆盖到i上，并使j减去step步长。
- 如果不条件，就不进行操作。最后统一进行赋值。不变就是自己给自己赋值，改变就是交换值。
记忆要点
比较间隔step步长的两个元素，小的放前面。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10，每一步长的循环都会使数组顺序得到一定的修正。
代码展示
/**
* 希尔排序算法: 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
* 要点：小的在左,按step步长比较交换
*/
public class ShellSort {
public int[] shellSort(int[] arr) {
int length = arr.length;
int temp;
// 3 2 15 4 19 27 5 38 36 26 3 2 5 4 15 26 19 27 36 38 2 3 4 5 15 19 26 27 36 38
// step: 5 2 1
for (int step = length / 2; step >= 1; step /= 2) {
//i: 56789 23456789 123456789
for (int i = step; i < length; i++) {
temp = arr[i];
//j: 01234 01234567 012345678
int j = i - step;
while (j >= 0 && arr[j] > temp) {
arr[j + step] = arr[j];
//j与下一个step步长进行比较
j -= step;
}
//如果不走while,j+step==i,自己赋值给自己，如果走就是互换值
arr[j + step] = temp;
}
}
return arr;
}
public static void main(String[] args) {
ShellSort shell = new ShellSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = shell.shellSort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
05归并排序
算法简介
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。
算法步骤
- 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
- 重复步骤 3 直到某一指针达到序列尾；
- 将另一序列剩下的所有元素直接复制到合并序列尾。
记忆要点
就是单纯的合并两个数组，相互比较，难点是开头的递归拆分到最小单位。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10，最重要的就是搞清楚递归的过程，合并就是比较并不难。
代码展示
/**
* 归并排序算法:申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；设定两个指针，最初位置分别为两个已经排序序列的起始位置；
* 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；重复步骤 3 直到某一指针达到序列尾；将另一序列剩下的所有元素直接复制到合并序列尾。
* 要点：先递归分类成最小单位，然后一步一步结束递归合并，分治思想
* 3, 5, 15, 36, 26, 27, 2, 38, 4, 19
*/
public class MergeSort {
//用于递归来进行分段，将数组递归分成最小单位，然后再比较合并到一个数组里
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
//如果只有一个元素就直接返回
if (arr.length < 2) {
return arr;
}
int middle = (int) Math.floor(arr.length / 2);
//左半部分
int[] left = Arrays.copyOfRange(arr, 0, middle);
//右半部分
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
//合并
return merge(sort(left), sort(right));
}
protected int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int i = 0;
//如果左边数组有元素，同时右边数组也有元素，就进行依次比较，将小的放入到result，直到左右之一没有元素
while (left.length > 0 && right.length > 0) {
if (left[0] <= right[0]) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
} else {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
//当只有左边有元素，就把左边所有元素都赋值到result
while (left.length > 0) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
//当只有右边有元素，就把右边所有元素都赋值到result
while (right.length > 0) {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
public static void main(String[] args) throws Exception {
MergeSort marge = new MergeSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = marge.sort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
06快速排序
算法简介
快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。虽然 Worst Case 的时间复杂度达到了 O(n²)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好。
快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。
算法步骤
- 从数列中挑出一个元素，称为 “基准”（pivot）;
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
记忆要点
根据基准值，找到比基准值小的放在右边，等便利完后再将基准值和最后一个最小值进行交换，也就是放在中间位置。（建议放最后掌握）
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10，找基准值放中间，重复此过程。（确实挺难）
代码展示
/**
* 快速排序算法: 从数列中挑出一个元素，称为 "基准"（pivot）;重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
* 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
* 要点：选基准，比大小，小先放右边，基准再换位
* 3, 5, 15, 36, 26, 27, 2, 38, 4, 19
*/
public class QuickSort {
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return quickSort(arr, 0, arr.length - 1);
}
private int[] quickSort(int[] arr, int left, int right) {
if (left < right) {
// 0 9 2 9 4 9 5 9 7 9
int partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex - 1);
quickSort(arr, partitionIndex + 1, right);
}
return arr;
}
//{3, 5, 15, 36, 26, 27, 2, 38, 4, 19}
private int partition(int[] arr, int left, int right) {
// 设定基准值（pivot） 3 15 15
int pivot = left;
int index = pivot + 1;
for (int i = index; i <= right; i++) {
//把小于基准的放在右边 2 3 15 36 26 27 5 38 4 19 2 3 4 5 15 27 36 38 26 19 2 3 4 5 15 19 26 27 36 38
if (arr[i] < arr[pivot]) {
swap(arr, i, index);
index++;
}
}
//把基准值放中间
swap(arr, pivot, index - 1);
return index - 1;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void main(String[] args) throws Exception {
QuickSort quick = new QuickSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = quick.sort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
07堆排序
算法简介
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：
- 大根堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
- 小根堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
堆排序的平均时间复杂度为 Ο(nlogn)。
算法步骤
- 根据所给的数组，创建对应的堆结构。
- 调整创建完成的堆结构，使之形成大根堆（或小根堆）。
- 拆解当前最大的根，然后从右到左，从下到上与要拆解的根进行交换，交换完毕调整堆，使其满足大根堆条件。
- 重复c步骤，直到结束。
记忆要点
堆的构建，调整，拆解至关重要，堆只是一种虚拟的结构。计算机中只能构建其神，构建不出其形。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10。
代码展示
public class HeapSort {
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int len = arr.length;
buildMaxHeap(arr, len);
for (int i = len - 1; i > 0; i--) {
//拆除顶根
swap(arr, 0, i);
len--;
//重新调整堆，使其符合大根堆
heapify(arr, 0, len);
}
return arr;
}
private void buildMaxHeap(int[] arr, int len) {
for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
heapify(arr, i, len);
}
}
private void heapify(int[] arr, int i, int len) {
//largest 当前根 left 左孩子 right 右孩子
int left = 2 * i + 1;
int right = 2 * i + 2;
int largest = i;
//大根堆就是找到左右最大的，进行交换；小根堆就是找到左右最小的，进行交换。
// arr[largest]就是根 找当前节点中最大的最为根 <就是小根堆 >就是大根堆
if (left < len && arr[left] < arr[largest]) {
largest = left;
}
// <就是小根堆 >就是大根堆
if (right < len && arr[right] < arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
//为了保证每次当前根下的堆是最小堆
heapify(arr, largest, len);
}
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void main(String[] args) throws Exception {
HeapSort heap = new HeapSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = heap.sort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
08计数排序
算法简介
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。
由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。
通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。
算法步骤
- 找出待排序的数组中最大和最小的元素
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
记忆要点
通过一个额外数组，进行遍历计数，再将额外数组遍历赋值回原数组。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10。
代码展示
public class CountingSort {
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
//获取数组元素最大值
int maxValue = getMaxValue(arr);
return countingSort(arr, maxValue);
}
private int[] countingSort(int[] arr, int maxValue) {
//最大值+1，创建数组用来计数
int bucketLen = maxValue + 1;
int[] bucket = new int[bucketLen];
//遍历数组，将相同的值，放到bucket相同地方，并次数+1
for (int value : arr) {
bucket[value]++;
}
//根据bucket数组的次数，进行赋值arr,得到最终结果
int sortedIndex = 0;
for (int j = 0; j < bucketLen; j++) {
while (bucket[j] > 0) {
arr[sortedIndex++] = j;
bucket[j]--;
}
}
return arr;
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
public static void main(String[] args) throws Exception {
CountingSort count = new CountingSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = count.sort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
09桶排序
算法简介
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：
- 在额外空间充足的情况下，尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。当数组中的值被均匀分到每个桶时，排序最快；当数组中的值，都被集中分到一个桶里时，速度最慢。
算法步骤
- 找到数组的最大最小值，根据设计的桶的大小，计算出桶的数量。
- 遍历数组，将每个元素放到各自所属的桶中
- 遍历每个桶，将桶内的元素进行排序，自己选择排序算法
- 最后，将每个桶中的元素依次赋值到原数组上。
记忆要点
先分桶，再桶内排序，最后赋值原数组。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
先分桶
再排序
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10。
代码展示
public class BucketSort {
private static final InsertionSort insertSort = new InsertionSort();
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return bucketSort(arr, 5);
}
private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
if (arr.length == 0) {
return arr;
}
int minValue = arr[0];
int maxValue = arr[0];
for (int value : arr) {
if (value < minValue) {
minValue = value;
} else if (value > maxValue) {
maxValue = value;
}
}
//计算出桶的大小和数量
int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
int[][] buckets = new int[bucketCount][0];
// 利用映射函数将数据分配到各个桶中
for (int i = 0; i < arr.length; i++) {
int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
buckets[index] = arrAppend(buckets[index], arr[i]);
}
int arrIndex = 0;
for (int[] bucket : buckets) {
if (bucket.length <= 0) {
continue;
}
// 对每个桶进行排序，这里使用了插入排序
bucket = insertSort.insertionSort(bucket);
for (int value : bucket) {
arr[arrIndex++] = value;
}
}
return arr;
}
/**
* 自动扩容，并保存数据
*
* @param arr
* @param value
*/
private int[] arrAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}
public static void main(String[] args) throws Exception {
BucketSort bucket = new BucketSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = bucket.sort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
10基数排序
算法简介
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
基数排序 vs 计数排序 vs 桶排序这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：
- 基数排序：根据键值的每位数字来分配桶；
- 计数排序：每个桶只存储单一键值；
- 桶排序：每个桶存储一定范围的数值；
算法步骤
- 通过查找数组的最大值，从而获得数组的最高位数
- 对每一位进行排序，从个位开始，把个位排完序就赋值到原数组，这算一轮。
- 然后再对第二位进行排序，循环第二步，知道把最高位也排序完成。
记忆要点
通过位数分配桶，按照位数形成外循环，每一次循环都会使原数组更有序。
动画展示
此动画来源于网络，只用于展示过程辅助理解，与具体例子不一样。
算法演示
举例数组： [3, 5, 15, 36, 26, 27, 2, 38, 4, 19] 长度为10。
代码展示
public class RadixSort {
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int maxDigit = getMaxDigit(arr);
return radixSort(arr, maxDigit);
}
/**
* 获取最高位数
*/
private int getMaxDigit(int[] arr) {
int maxValue = getMaxValue(arr);
return getNumLenght(maxValue);
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
protected int getNumLenght(long num) {
if (num == 0) {
return 1;
}
int lenght = 0;
for (long temp = num; temp != 0; temp /= 10) {
lenght++;
}
return lenght;
}
private int[] radixSort(int[] arr, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
// 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < arr.length; j++) {
int bucket = ((arr[j] % mod) / dev) + mod;
counter[bucket] = arrayAppend(counter[bucket], arr[j]);
}
int pos = 0;
for (int[] bucket : counter) {
for (int value : bucket) {
arr[pos++] = value;
}
}
}
return arr;
}
/**
* 自动扩容，并保存数据
*
* @param arr
* @param value
*/
private int[] arrayAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}
public static void main(String[] args) throws Exception {
RadixSort radix = new RadixSort();
int[] arr = {3, 5, 15, 36, 26, 27, 2, 38, 4, 19};
int[] resultArr = radix.sort(arr);
for (int i = 0; i < resultArr.length; i++) {
System.out.print(" " + resultArr[i]);
}
}
}
参考文档
- 菜鸟教程十大经典排序算法：https://www.runoob.com/w3cnote/ten-sorting-algorithm.html
- 一像素：https://www.cnblogs.com/onepixel/p/7674659.html
- 十大经典排序算法最强总结（含Java代码实现）：https://zhuanlan.zhihu.com/p/34894768
本文章所有代码及算法演示均验证过，如有任何问题请与我联系，如果你感觉有收获请点赞收藏。（一个专心学习和整理的菜鸟）
59
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
