冒泡排序
冒泡排序属于交换类的排序算法，比如有一段乱序的数，5 9 1 6 8 14 6 49 25 4 6 3
第一轮迭代： 从第一个数开始，依次比较相邻的两个数，如果后面的一个数比前面的一个数大，那么交换位置，直接到处理最后一个数，最后这个数是最大的
第二轮迭代，因为最后一个数已经是最大的了，重复第一轮操作，但是只处理倒数第二个数
第三轮迭代，因为最后一个数已经是最大的了，最后第二个数是次大的，重复第一轮迭代操作，但是处理第倒数第三个数。
因为小的元素会慢慢浮现到顶端，就想像气泡一样，会冒上去，所以这就是冒泡排序的来源。
[]表示排好序 {}表示比较后交换的结果
第一轮开始： 4 2 9 1 从第一个数开始，4 比 2 大，交换 4，2
第一轮： {2 4} 9 1 接着 4 比 9 小，不交换
第一轮： 2 {4 9} 1 接着 9 比 1 大，交换 9，1
第一轮： 2 4 {1 9} 已经到底，结束
第一轮结果： 2 4 1 [9]
第二轮开始：2 4 1 [9] 从第一个数开始，2 比 4 小，不交换
第二轮： {2 4} 1 [9] 接着 4 比 1 大，交换 4，1
第二轮： 2 {1 4} [9] 已经到底，结束
第二轮结果： 2 1 [4 9]
第三轮开始：2 1 [4 9] 从第一个数开始，2 比 1 大，交换 2，1
第三轮： (1 2} [4 9] 已经到底，结束
第三轮结果： 1 [2 4 9]
结果： [1 2 4 9]当数列的元素数量为 N，冒泡排序有两种循环，需要比较的次数为：
第一次比较的次数为： N-1 次
第二次比较的次数为： N-2 次，因为排除了最后的元素
第三次比较的次数为： N-3 次，因为排除了后两个元素
...
第某次比较的次数为： 1 次算法实现
package main
import "fmt"
func BubbleSort(list []int) {
n := len(list)
// 在一轮中有没有交换过
didSwap := false
// 进行 N-1 轮迭代
for i := n - 1; i > 0; i-- {
// 每次从第一位开始比较，比较到第 i 位就不比较了，因为前一轮该位已经有序了
for j := 0; j < i; j++ {
// 如果前面的数比后面的大，那么交换
if list[j] > list[j+1] {
list[j], list[j+1] = list[j+1], list[j]
didSwap = true
}
}
// 如果在一轮中没有交换过，那么已经排好序了，直接返回
if !didSwap {
return
}
}
}
func main() {
list := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
BubbleSort(list)
fmt.Println(list)
}输出：
[1 3 4 5 6 6 6 8 9 14 25 49]
