耐心和持久胜过激烈和狂热。
哈喽大家好，我是陈明勇，今天分享的内容是使用 Go 实现冒泡排序算法。如果本文对你有帮助，不妨点个赞，如果你是 Go 语言初学者，不妨点个关注，一起成长一起进步，如果本文有错误的地方，欢迎指出！
冒泡排序
冒泡排序是交换排序中最简单的一种算法。 算法思路：
- 遍历数组，相邻的两个元素进行比较，以升序为例，如果前面的元素大于后面的元素，则将它们的位置进行交换
- 第一轮遍历结束之后，最大的元素会处于所遍历范围的最后一个位置，然后继续下一轮遍历
- 每轮都会固定一个元素，直到所有元素都被固定，因此会执行 n - 1轮，n 为元素的个数，也就是数组（切片）的长度。为什么会是 n - 1 而不是 n，因为到了第 n 轮，只剩下最后一个元素没有被固定，没有元素可以和它进行比较了，因此第 n 轮可以忽略。
图片演示
- 第一轮遍历 [4, 2, 1, 3]
- i = 0 时，比较第 i 个元素 4 与第 i + 1 个元素 2 的大小，因为 nums[i] > num[i+1]，也就是 4 > 2，因此交换它们的位置。
- i = 1 时，4 > 1，互换位置。
- i = 2 时，4 > 3，互换位置。最大值 4 被交换到最后一个位置，此时所有元素都参与比较过了，结束第一轮遍历，执行下一轮遍历。
- 第二轮遍历 [2, 1, 3, 4]
- i = 0 时，2 > 1，互换位置。
- i = 1 时，2 < 3，不做交换。次大值 3 被交换到 4 的左边，此时所有元素都参与比较过了，结束第二轮遍历，执行下一轮遍历。
- 第三轮遍历 [1, 2, 3, 4]
- i = 0 时，1 < 2，不做交换。此时所有元素都参与比较过了，结束第三轮遍历，
- 执行了 n - 1 轮遍历，n 为数组的长度，n - 1个元素被交换到正确的位置，第 n 轮遍历时，只剩最后一个元素，因此不用继续进行。
普通的冒泡排序算法
import "fmt"
func main() {
nums := []int{4, 2, 1, 3}
NormalBubbleSort(nums)
fmt.Println("排序后的数组：", nums)
}
func NormalBubbleSort(nums []int) {
for i := 0; i < len(nums)-1; i++ {
for j := 0; j < len(nums)-i-1; j++ {
if nums[j] > nums[j+1] {
nums[j], nums[j+1] = nums[j+1], nums[j]
}
}
fmt.Printf("第 %d 轮遍历后的数组：%v\n", i+1, nums)
}
}
执行结果：
第 1 轮遍历后的数组：[2 1 3 4]
第 2 轮遍历后的数组：[1 2 3 4]
第 3 轮遍历后的数组：[1 2 3 4]
排序后的数组： [1 2 3 4]
值得注意的一个地方是第二层循环的条件 j < len(nums)-i-1，为什么会减去 i，因为每轮遍历结束之后，都会有一个元素被固定到后面，因此再进行下一轮的时候，那个元素无须再进行比较。
优化算法
根据普通的冒泡排序算法的结果显示，第二轮和第三轮的数组排序是一样的，也就是说第三轮没有进行元素交换，对此我们可以优化算法，如果有一轮遍历没有交换元素，则终止遍历，因为所有元素都处于正确位置，所以没有进行元素交换。
import "fmt"
func main() {
nums := []int{4, 2, 1, 3, 5}
NBBubbleSort(nums)
fmt.Println("排序后的数组：", nums)
}
func NBBubbleSort(nums []int) {
isSwapped := true
for isSwapped {
isSwapped = false
for i := 0; i < len(nums)-1; i++ {
if nums[i] > nums[i+1] {
nums[i], nums[i+1] = nums[i+1], nums[i]
isSwapped = true
}
}
fmt.Println("遍历后的数组：", nums)
}
}
执行结果：
遍历后的数组： [2 1 3 4 5]
遍历后的数组： [1 2 3 4 5]
遍历后的数组： [1 2 3 4 5]
排序后的数组： [1 2 3 4 5]
