目录：
- 冒泡排序
- 选择排序
- 插入排序
- 希尔排序
- 归并排序
- 快速排序
- 堆排序
- 计数排序
- 桶排序
- 基数排序
简介：（本文是根据菜鸟教程的二次创做）
- 排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：
关于稳定性
- 排序的稳定性是指在排序算法中，对于相等的元素，它们在排序后的相对顺序是否保持不变。如果一个排序算法具有稳定性，那么当两个元素相等时，它们在排序后的位置将不会改变。
- 稳定的排序算法：冒泡排序、插入排序、归并排序、基数排序。
- 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。
1.冒泡排序
简介：
- 冒泡排序也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。
算法步骤：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
动图演示：
代码实现：
package leetcode.sort;
import java.util.Arrays;
public class BubbleSort {
public int[] bubble_sort(int[] sourceArray) {
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
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) {
BubbleSort bubbleSort = new BubbleSort();
int[] arr = new int[]{1, 3, 5, 7, 3, 9, 6, 3};
int[] ret = bubbleSort.bubble_sort(arr);
for (int i : ret) {
System.out.print(i + " ");
}
}
}
适用场景：
冒泡排序是一种简单的排序算法，适用于数据量较小并且对稳定性有要求的基本有序的场景。以下是冒泡排序的适用场景：
- 小规模数据排序：当数据量较小，如4个数字进行排序时，冒泡排序是一种简单有效的方法。例如，在手动编写排序算法时，可以用冒泡排序对几个数进行排序。
- 教学场景：由于冒泡排序的逻辑比较简单，易于理解，因此在给初学者讲解排序算法时，经常使用冒泡排序作为示例。通过演示和讲解冒泡排序的原理和过程，可以帮助学生更好地理解排序算法的基本概念和实现方法。
- 特定需求：在一些特殊的应用场景中，冒泡排序也有其适用之处。例如，在某些特定的游戏逻辑中，如果需要按照一定顺序排列物品或角色，而数据量又比较小，可以使用冒泡排序。
需要注意的是，冒泡排序的时间复杂度较高，最坏为O(n^2)，因此在实际应用中，对于大规模数据的排序，冒泡排序并不是最优选择。在这种情况下，应该选择更高效的排序算法，如快速排序、归并排序等。
2.选择排序
简介：
- 选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
算法步骤：
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
- 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
- 重复第二步，直到所有元素均排序完毕。
动图演示：
代码实现：
package leetcode.sort;
import java.util.Arrays;
public class SelectSort {
public int[] select_sort(int[] sourceArray) {
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (i != min) {
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
return arr;
}
public static void main(String[] args) {
SelectSort selectSort = new SelectSort();
int[] arr = new int[]{1, 3, 5, 7, 3, 9, 6, 3};
int[] ret = selectSort.select_sort(arr);
for (int i : ret) {
System.out.print(i + " ");
}
}
}
适用场景：
选择排序适用于数据量较小且数据基本有序的情况。以下是选择排序的适用场景：
- 数据量较小：选择排序的时间复杂度为O(n^2)，当数据量较小的时候，这种算法的运行速度可以接受。在数据量较小的场景下，选择排序可以作为一种有效的排序方法。
- 数据基本有序：如果数据已经基本有序，那么选择排序的性能会更好。这是因为选择排序在寻找最小（或最大）元素时，只需要进行一次线性搜索，时间复杂度为O(n)。
- 稳定性要求不高：选择排序是一种不稳定的排序算法，对于相等的元素，它们在排序后的相对顺序可能会改变。如果稳定性不是关键要求，那么选择排序可以作为一种备选方案。
需要注意的是，选择排序在大规模数据的排序中并不适用，因为其时间复杂度较高，会导致算法效率低下。在实际应用中，应该根据具体需求选择合适的排序算法。
3. 插入排序
简介：
- 插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。
算法步骤：
- 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
动图演示：
代码实现：
package leetcode.sort;
import java.util.Arrays;
public class InsertSort {
public int[] insert_sort(int[] sourceArray) {
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
for (int i = 1; i < arr.length; i++) {
int tmp = arr[i];
int j = i;
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1];
j--;
}
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}
public static void main(String[] args) {
InsertSort insertSort = new InsertSort();
int[] arr = new int[]{1, 3, 5, 7, 3, 9, 6, 3};
int[] ret = insertSort.insert_sort(arr);
for (int i : ret) {
System.out.print(i + " ");
}
}
}
适用场景：
插入排序适用于数据量较小且数据基本有序的情况。以下是插入排序的适用场景：
- 数据量较小：插入排序的时间复杂度为O(n^2)，当数据量较小的时候，这种算法的运行速度可以接受。在数据量较小的场景下，插入排序可以作为一种有效的排序方法。
- 数据基本有序：如果数据已经基本有序，那么插入排序的性能会更好。这是因为插入排序在插入元素时，只需要进行一次线性搜索，时间复杂度为O(n)。
- 稳定性要求较高：插入排序是一种稳定的排序算法，对于相等的元素，它们在排序后的相对顺序保持不变。如果稳定性是关键要求，那么插入排序可以作为一种备选方案。
需要注意的是，插入排序在大规模数据的排序中并不适用，因为其时间复杂度较高，会导致算法效率低下。在实际应用中，应该根据具体需求选择合适的排序算法。
4.希尔排序
简介：
- 希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
- 希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
- 希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
算法步骤：
- 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
- 按增量序列个数 k，对序列进行 k 趟排序；
- 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
动图演示：
代码实现：
package leetcode.sort;
import java.util.Arrays;
public class ShellSort {
public int[] shell_sort(int[] sourceArray) {
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int len = arr.length;
for (int step = len / 2; step >= 1; step /= 2) {
for (int i = step; i < len; i++) {
int tmp = arr[i];
int j = i - step;
while (j >= 0 && arr[j] > tmp) {
arr[j + step] = arr[j];
j -= step;
}
arr[j + step] = tmp;
}
}
return arr;
}
public static void main(String[] args) {
ShellSort shellSort = new ShellSort();
int[] arr = new int[]{1, 3, 5, 7, 3, 9, 6, 3};
int[] ret = shellSort.shell_sort(arr);
for (int i : ret) {
System.out.print(i + " ");
}
}
}
适用场景：
希尔排序适用于中规模数据量的排序。以下是希尔排序的适用场景：
- 中规模数据量：希尔排序是对直接插入排序的一种优化，它通过比较相隔某个“增量”的元素，可以将大量元素进行快速排序。希尔排序比直接插入排序和选择排序要快的多，并且数组越大，优势越大。因此，希尔排序适用于中规模数据量的排序。
- 部分有序的数据：如果数据已经部分有序，那么希尔排序的性能会更好。这是因为希尔排序在增量序列的选择上，可以利用部分有序的数据特性，选择合适的增量序列，从而提高算法的效率。
- 稳定性要求不高：希尔排序是一种不稳定的排序算法，对于相等的元素，它们在排序后的相对顺序可能会改变。如果稳定性不是关键要求，那么希尔排序可以作为一种备选方案。
需要注意的是，希尔排序不适用于链式存储结构，因为增量初始值不容易选择，所以该算法不常用。在实际应用中，应该根据具体需求选择合适的排序算法。
5.归并排序
简介：
算法步骤：
动图演示：
代码实现：
适用场景：
6.快速排序
简介：
算法步骤：
动图演示：
代码实现：
适用场景：
7.堆排序
简介：
算法步骤：
动图演示：
代码实现：
适用场景：
8.计数排序
简介：
算法步骤：
动图演示：
代码实现：
适用场景：
9.桶排序
简介：
算法步骤：
动图演示：
代码实现：
适用场景：
10.基数排序
简介：
算法步骤：
动图演示：
代码实现：
适用场景：
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
