主要是三种排序方法：冒泡排序、选择排序、插入排序。
[2. 工作原理](#2. 工作原理)
一、冒泡排序
通过重复遍历待排序的列表，比较相邻元素并交换顺序错误的元素。(其名称源于较小的元素会像"气泡"一样逐渐"浮"到列表顶端。)
1.代码：
代码如下（示例）：
cs
//冒泡排序
//从小到大
int main()
{
int i = 0;//i表示趟数
int j = 0;
int a[5] = { 5,3,8,4,6 };
for (i = 0; i < 5; i++)//至少4趟，这里也可以写成i<4
{
for (j = 0; j < 5-i-1; j++)
{
if (a[j] > a[j + 1])
{
int tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
}
for (i = 0; i < 5; i++)
{
printf("%d ", a[i]);
}
return 0;
}2.工作原理：
**比较相邻元素**：从列表的第一个元素开始，比较相邻的两个元素。
**交换元素**：如果顺序错误（如前一个元素大于后一个元素），则交换它们。
**重复遍历**：重复上述步骤，直到没有需要交换的元素，列表排序完成。
3.具体过程：
- **第一轮**：
比较 5 和 3，交换，得 `[3, 5, 8, 4, 6]`
比较 5 和 8，不交换
比较 8 和 4，交换，得 `[3, 5, 4, 8, 6]`
比较 8 和 6，交换，得 `[3, 5, 4, 6, 8]`
第一轮结束，最大的元素 8 已"浮"到末尾。
- **第二轮**：
比较 3 和 5，不交换
比较 5 和 4，交换，得 `[3, 4, 5, 6, 8]`
比较 5 和 6，不交换
第二轮结束，第二大的元素 6 已"浮"到倒数第二位。
- **第三轮**：
比较 3 和 4，不交换
比较 4 和 5，不交换
第三轮结束，列表已排序完成。
最终排序结果为 `[3, 4, 5, 6, 8]`。
时间复杂度
-
**最坏情况**：O(n²)，列表完全逆序时。
-
**平均情况**：O(n²)。
-
**最好情况**：O(n)，列表已经有序时。
优点
-
实现简单。
-
对小规模数据有效。
缺点
-
效率低，尤其对大规模数据。
-
需要多次遍历和交换。
适用场景
适用于数据量小或对性能要求不高的场景。
二、选择排序
通过不断选择未排序部分的最小元素，并将其放到已排序部分的末尾。其核心思想是每次从未排序部分选出最小元素，与未排序部分的第一个元素交换。
1.代码
代码如下（示例）：
cs
//选择排序
int main()
{
int i = 0;//i表示趟数
int j = 0;
int a[5] = { 64,65,12,22,11 };
for (i = 0; i < 5; i++)//选择排序次数
{
int min = i;//假设每一趟第一个元素是最小的
for (j = i; j < 5 ; j++)//元素个数
{
if (a[min]>a[j])
{
min = j;
}
}
int tmp = a[i];
a[i] = a[min];
a[min] = tmp;
}
for (i = 0; i < 5; i++)
{
printf("%d ", a[i]);
}
return 0;
}2. 工作原理
**找到最小元素**：在未排序部分中找到最小元素。
**交换元素**：将最小元素与未排序部分的第一个元素交换。
**重复步骤**：重复上述过程，直到所有元素排序完成。
3.具体过程：
- **第一轮**：
找到最小元素 11，与第一个元素 64 交换，得 `[11, 25, 12, 22, 64]`
已排序部分为 `[11]`，未排序部分为 `[25, 12, 22, 64]`
- **第二轮**：
找到最小元素 12，与第一个元素 25 交换，得 `[11, 12, 25, 22, 64]`
已排序部分为 `[11, 12]`，未排序部分为 `[25, 22, 64]`
- **第三轮**：
找到最小元素 22，与第一个元素 25 交换，得 `[11, 12, 22, 25, 64]`
已排序部分为 `[11, 12, 22]`，未排序部分为 `[25, 64]`
- **第四轮**：
找到最小元素 25，已在正确位置，无需交换。
已排序部分为 `[11, 12, 22, 25]`，未排序部分为 `[64]`
- **第五轮**：
最后一个元素 64 已在正确位置。
最终排序结果为 `[11, 12, 22, 25, 64]`
时间复杂度
-
**最坏情况**：O(n²)，列表完全逆序时。
-
**平均情况**：O(n²)。
-
**最好情况**：O(n²)，即使列表已经有序，仍需进行相同次数的比较。
优点
-
实现简单。
-
对小规模数据有效。
缺点
-
效率低，尤其对大规模数据。
-
需要多次遍历和交换。
适用场景
适用于数据量小或对性能要求不高的场景。
三、插入排序
通过构建有序序列，逐步将未排序部分的元素插入到已排序部分的适当位置。其核心思想是将每个未排序元素插入到已排序部分的正确位置，直到所有元素排序完成。
1.代码
代码如下（示例）：
cs
int main() {
int arr[] = {12, 11, 13, 5, 6};
int n = sizeof(arr) / sizeof(arr[0]);
// 插入排序（直接写在 main 里）
for (int i = 1; i < n; i++) {
int key = arr[i]; // 当前要插入的元素
int j = i - 1; // 已排序部分的最后一个位置
// 把比 key 大的元素往后移
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key; // 插入到正确位置
}
// 输出排序后的数组
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}外层循环：从第 2 个元素（`i = 1`）开始遍历数组，因为第一个元素默认是"已排序"的。
内层循环：从 `i - 1` 开始往前找，如果 `arr[j] > key`，就把 `arr[j]` 往后移一位。
直到找到 `arr[j] <= key` 的位置，然后把 `key` 插入到 `j + 1` 的位置。
2.工作原理
**初始状态**：将第一个元素视为已排序部分，其余元素为未排序部分。
**插入元素**：从未排序部分取出第一个元素，与已排序部分的元素从后向前比较，找到合适的位置插入。
**重复步骤**：重复上述过程，直到所有元素排序完成。
3.具体过程
- **第一轮**：
已排序部分为 `[12]`，未排序部分为 `[11, 13, 5, 6]`
取出 11，与 12 比较，插入到 12 前面，得 `[11, 12, 13, 5, 6]`
已排序部分为 `[11, 12]`，未排序部分为 `[13, 5, 6]`
- **第二轮**：
取出 13，与 12 比较，插入到 12 后面，得 `[11, 12, 13, 5, 6]`
已排序部分为 `[11, 12, 13]`，未排序部分为 `[5, 6]`
- **第三轮**：
取出 5，与 13、12、11 比较，插入到 11 前面，得 `[5, 11, 12, 13, 6]`
已排序部分为 `[5, 11, 12, 13]`，未排序部分为 `[6]`
- **第四轮**：
取出 6，与 13、12、11、5 比较，插入到 5 后面，得 `[5, 6, 11, 12, 13]`
已排序部分为 `[5, 6, 11, 12, 13]`，未排序部分为空
时间复杂度
-
**最坏情况**：O(n²)，列表完全逆序时。
-
**平均情况**：O(n²)。
-
**最好情况**：O(n)，列表已经有序时。
优点
-
实现简单。
-
对小规模数据或基本有序的数据有效。
缺点
-
效率低，尤其对大规模数据。
-
需要多次比较和移动。
适用场景
适用于数据量小或基本有序的数据集。
总结
主要是三种排序方法：冒泡排序、选择排序、插入排序。
以及它们的工作原理，具体的工作流程，时间复杂度空间复杂度和适用场景