目录
[1. 算法包](#1. 算法包)
[2. 选择排序代码](#2. 选择排序代码)
[3. 模拟排序](#3. 模拟排序)
[4. 运行程序](#4. 运行程序)
[5. 从大到小排序](#5. 从大到小排序)
[假如 10 条数据进行排序](#假如 10 条数据进行排序)
[假如 20 条数据进行排序](#假如 20 条数据进行排序)
[假如 30 条数据进行排序](#假如 30 条数据进行排序)
[假设 5000 条数据，对比 冒泡、插入、快速、堆、归并](#假设 5000 条数据，对比 冒泡、插入、快速、堆、归并)
[1. 数据规模非常小](#1. 数据规模非常小)
[2. 稳定性不重要](#2. 稳定性不重要)
[3. 几乎全部数据已排序](#3. 几乎全部数据已排序)
[4. 教育目的](#4. 教育目的)
前言
在实际场景中，选择合适的排序算法对于提高程序的效率和性能至关重要，本节课主要讲解"选择排序"的适用场景及代码实现。
选择排序
选择排序(Selection Sort) 是一种简单直观的排序算法，它的工作原理是：首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
代码示例
下面我们使用Go语言实现一个选择排序：
1. 算法包
创建一个 pkg/algorithm.go
bash
touch pkg/algorithm.go(如果看过上节课的冒泡排序，则已存在该文件，我们就不需要再创建了)
2. 选择排序代码
打开 pkg/algorithm.go文件，代码如下
从小到大 排序
Go
package pkg
// BubbleSort 冒泡排序
...
// SelectionSort 选择排序
func SelectionSort(arr []int) {
n := len(arr) // 获取切片长度
for i := 0; i < n-1; i++ {
// 假设当前位置是最小的
minIndex := i
// 遍历未排序的部分，寻找真正的最小值的索引
for j := i + 1; j < n; j++ {
if arr[j] < arr[minIndex] {
minIndex = j
}
}
// 如果找到更小的数，就交换
arr[i], arr[minIndex] = arr[minIndex], arr[i]
}
}3. 模拟排序
打开 main.go 文件，代码如下：
Go
package main
import (
"demo/pkg"
"fmt"
)
func main() {
// 定义一个切片，这里我们模拟 10 个元素
arr := []int{789, 59, 1500, 847, 633, 2456, 901, 2, 752, 100}
fmt.Println("Original data:", arr) // 先打印原始数据
pkg.SelectionSort(arr) // 调用选择排序
fmt.Println("New data: ", arr) // 后打印排序后的数据
}4. 运行程序
打开终端，我们运行 go ：
bash
go run main.go
能发现， Original data 后打印的数据，正是我们代码中定义的切片数据，顺序也是一致的。
New Data 后打印的数据，则是经过选择排序后的数据，是从小到大的。
5. 从大到小排序
如果需要 从大到小 排序也是可以的，在代码里，将两个元素比较的 小于符号 改成 大于符号 即可。
修改 pkg/algorithm.go 文件：
Go
package pkg
// BubbleSort 冒泡排序
...
// SelectionSort 选择排序
func SelectionSort(arr []int) {
n := len(arr) // 获取切片长度
for i := 0; i < n-1; i++ {
// 假设当前位置是最小的
minIndex := i
// 遍历未排序的部分，寻找真正的最小值的索引
for j := i + 1; j < n; j++ {
if arr[j] > arr[minIndex] {
minIndex = j
}
}
// 如果找到更小的数，就交换
arr[i], arr[minIndex] = arr[minIndex], arr[i]
}
}只需要一丁点的代码即可
从 package pkg 算第一行，上面示例中在第十四行代码中，我们将 "<" 改成了 ">" ，这样就变成了 从大到小排序了
补充：
代码里还有一处可以完善，在最后两个数进行交换时
思考一下这一行代码：
Go
arr[i], arr[minIndex] = arr[minIndex], arr[i]如果，arr[minIndex] 和 arr[i] 这两个数是相同的，那么还有必要进行交换吗？
当然是可以不用交换，所以我们可以再加上一个判断：
Go
// 如果它们不相等
if arr[minIndex] != arr[i] {
// 如果找到更小的数，就交换
arr[i], arr[minIndex] = arr[minIndex], arr[i]
}循环细节
在选择排序算法中，外层循环和内层循环扮演着至关重要的角色，它们共同协作以实现对整个数组的排序。下面是这两个循环的详细说明
外层循环
- 目的：外层循环负责控制排序的轮次。对于包含 n 个元素的数组，外层循环需要进行 n - 1 轮排序(因为当只剩下一个元素时，它自然就是排序好的)。每一轮排序都会从未排序的部分找到一个最小(或最大)的元素，并将其放到已排序部分的末尾
- 起始与结束：外层循环通常从一个起始索引(如 0)开始，直到达到数组长度减 1 (n - 1) 的索引结束。这是因为当外层循环到达 n - 1 时，所有元素都已经排好序，只剩下最后一个元素(即索引为 n - 1 的元素)，它自然就是已排序的
- 作用：在每一轮排序开始时，外层循环的索引(假设为 i )代表当前已排序部分的末尾。然后，内层循环会从未排序的部分(即索引 i + 1 到 n - 1 的部分)中找到一个最小(或最大)元素的索引，并与索引 i 处的元素进行可能的交换
内层循环
- 目的：内层循环负责在每一轮排序中，从未排序的部分找到最小(或最大)元素的索引。一旦找到，就可能与当前轮次的外层循环索引处的元素进行交换(如果它们不是同一个元素的话)
- 起始与结束：内层循环的起始索引通常是外层循环索引的下一个位置(即 i + 1)，而结束索引是数组的最后一个元素(即 n - 1)。这是因为内层循环需要遍历整个未排序的部分来找到最小(或最大)的元素
- 作用：在每一轮外层循环中，内层循环都会遍历未排序的部分，通常比较来找到最小(或最大)元素的索引。这个索引会被存储在某个变量中(如 minIndex)，以便在遍历结束后与外层循环索引处的元素进行可能的交换
- 交换：如果内层循环找到了一个比外层循环索引处更小的元素(即 minIndex 不等于外层循环的索引 i )，那么就需要进行交换操作，将这两个元素的位置互换。这样，外层循环索引处的元素就变成了当前轮次中未排序部分的最小(或最大)元素，被正确地放置在了已排序部分的末尾
总结
外层循环控制排序的轮次，每一轮都试图从未排序的部分找到一个最小(或最大)元素，并将其放置到正确的位置上。内层循环则负责在每一轮中执行这个查找和可能的交换操作。通过这两层循环的协作，整个数组最终被排序完成。
循环次数测试
按照上面示例进行测试：
假如 10 条数据进行排序
外层循环了 9次
内层循环了 45次
总计循环了 54次
假如 20 条数据进行排序
外层循环了 19次
内层循环了 190次
总计循环了 209次
假如 30 条数据进行排序
外层循环了 29次
内层循环了 435次
总计循环了 464次
...
会发现，仅仅只是增加了 10 条数据，或者是 20 条数据，循环次数则是成几倍甚至十倍增长，所以数据量稍微多一点，是不建议使用 选择排序
假设 5000 条数据，对比 冒泡、插入、快速、堆、归并
- 冒泡排序：循环次数 12,502,499 次
- 选择排序：循环次数 12,502,499 次
- 插入排序：循环次数 6,323,958 次
- 快速排序：循环次数 74,236 次
- 堆排序：循环次数 59,589 次
- 归并排序：循环次数 60,288 次
选择排序的适用场景
尽管选择排序在大多数现代应用中不是最高效的排序算法(其平均和最坏情况时间复杂度都是 O(n ^ 2))，但在某些特定场景下，它仍然有其用途
1. 数据规模非常小
对于非常小的数据集，选择排序在效率损失可能微不足道，而它实现简单，易于理解和实现
2. 稳定性不重要
选择排序不是稳定的排序算法(即相等元素的相对顺序可能会改变)。如果应用场景不需要保持元素的原始相对顺序，那么选择排序可以作为一个简单的选择
3. 几乎全部数据已排序
虽然理论上来说，即使数据几乎全部已排序，选择排序的效率也不会显著提升，但在某些特定应用中，如果已知数据集接近排序状态，并且算法设计可以利用这一点(例如，通过提前终止不必要的比较)。则可能略有优势。然而，这通常需要结合其他优化技巧
4. 教育目的
由于选择排序简单直观，它常被用于教学目的，帮助学生理解排序算法的基本概念和工作原理
总之，尽管存在更高效的排序算法，但在特定场景下，选择排序仍然有其用武之地。