1、冒泡排序
冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较相邻的两个元素，并在必要时交换它们的位置，直到没有任何一对元素需要交换为止。该算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
package main
import "fmt"
// 我们定义了一个名为`bubbleSort`的函数，该函数接收一个整数数组`arr`作为参数。
// 在函数内部，我们首先获取数组的长度`n`，然后使用两个嵌套的循环来遍历数组。在内部循环中，
// 我们比较相邻的两个元素，如果前一个元素比后一个元素大，则交换它们的位置。最后，
// 当内部循环结束时，我们可以确定该数组已经排好序。
func bubbleSort(arr []int) {
n := len(arr)
for i := 0; i < n-1; i++ {
for j := 0; j < n-i-1; j++ {
if arr[j] > arr[j+1] {
arr[j], arr[j+1] = arr[j+1], arr[j]
}
}
}
}
func main() {
arr := []int{64, 25, 12, 22, 11}
bubbleSort(arr)
fmt.Println("Sorted array:", arr)
}
代码输出内容：
Sorted array: [11 12 22 25 64]
第二个案例：
package main
import "fmt"
func main() {
s := []int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
var temp int
for i := 0; i < len(s)-1; i++ { // 比较9次
for j := 0; j < len(s)-1-i; j++ {
if s[j] > s[j+1] {
temp = s[j]
s[j] = s[j+1]
s[j+1] = temp
}
}
}
fmt.Println(s)
}
代码输出内容：
[0 1 2 3 4 5 6 7 8 9]
总结：
- 从切片头部开始，不断比较相邻的两个元素的大小，让较大的元素逐渐往后移动(交换两个元素的值)，直到切片的末尾。经过第一轮的比较，就可以找到最大的元素，并移动至最后一个位置。
- 第一轮结束后，继续第二轮。仍然从切片头部开始比较，让较大的元素逐渐往后移动，直到切片的倒出第二个元素为止。经过第二轮的比较，就可以找到次大的元素，并将它放到倒数第二的位置。
- 以此类推，进行n-1(n切片的长度)轮，"冒泡"后，就可以将所有的元素都排序好。
2、选择排序
选择排序（Selection Sort）是一种简单直观的排序算法，其基本思想是：首先在未排序的数列中找到最小（大）元素，然后将其存放到数列的起始位置，接着再从剩余未排序的元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
package main
import "fmt"
func main() {
s := []int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
for j := 0; j < len(s)-1; j++ {
min := s[j]
minIndex := j
for i := j + 1; i < len(s); i++ {
if min > s[i] {
min = s[i]
minIndex = i
}
}
if minIndex != j {
s[j], s[minIndex] = s[minIndex], s[j]
}
}
fmt.Println(s)
}
代码输出内容：
[0 1 2 3 4 5 6 7 8 9]
总结：
- 第一趟排序在所有待排序的n个记录中选出关键字最小的记录，将它与列表中第一个进行交换，使关键字最小的记录在数据表最前端。
- 第二趟在剩下的n-1记录中在选出关键字最小的记录，将其与数据表中的第二个记录交换位置，使关键字次小的记录处于数据表第二个位置。
- 重复这样的操作，最终实现数据表的升序排序。