耐心和持久胜过激烈和狂热。

哈喽大家好，我是陈明勇，今天分享的内容是使用 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 := [4]int{4, 2, 1, 3}
  fmt.Println("原数组：", nums)
  fmt.Println("--------------------------------")
  NormalBubbleSort(nums)
}

func NormalBubbleSort(nums [4]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)
  }
  fmt.Println("--------------------------------")
  fmt.Println("排序后的数组：", nums)
}

执行结果：

原数组： [4 2 1 3]
--------------------------------
第 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​​，因为每轮遍历结束之后，都会有一个元素被固定到后面，因此再进行下一轮的时候，那个元素无须再进行比较。
• 算法遍历次数为 n -1，每次遍历时元素比较的次数依次为 n - 1、n - 2、n - 3、···、3、2、1，将所有次数求和 = 1 + 2 + 3 + ··· + n - 2 + n - 1= n - 1 * (n - 1 + 1) / 2 = (n² - 1) / 2，因此时间复杂度为 O(n²)。

优化算法

上述例子中，对数组 [4,2,1,3] 进行排序，我们来看看对数组 [4,2,1,3,5] 进行排序，打印数组排序的变化过程中：

原数组： [4 2 1 3 5]
--------------------------------
第 1 轮遍历后的数组：[2 1 3 4 5]
第 2 轮遍历后的数组：[1 2 3 4 5]
第 3 轮遍历后的数组：[1 2 3 4 5]
第 4 轮遍历后的数组：[1 2 3 4 5]
--------------------------------
排序后的数组： [1 2 3 4 5]

不难看出，第三轮与第四轮遍历过程中，都没有进行元素交换位置的操作，对此我们可以推出一个结论，如果在一轮遍历中，没有进行元素交换位置的操作，那么此时数组的里所有元素都处于正确位置。 根据这个结论，我们可以对算法进行优化：

import "fmt"

func main() {
  nums := [5]int{4, 2, 1, 3, 5}
  fmt.Println("原数组：", nums)
  fmt.Println("--------------------------------")
  BestBubbleSort(nums)
}

func BestBubbleSort(nums [5]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)
  }
  fmt.Println("--------------------------------")
  fmt.Println("排序后的数组：", nums)
}

执行结果：

原数组： 
--------------------------------
遍历后的数组： [2 1 3 4 5]
遍历后的数组： [1 2 3 4 5]
遍历后的数组： [1 2 3 4 5]
--------------------------------
排序后的数组： [1 2 3 4 5]

• 定义交换的标记变量 ​​isSwapper​​​，作为第一层循环的条件，每轮遍历开始之后，将标记变量 ​​isSwapper​​​ 赋值为 ​​false​​​，如果在比较的过程中发生元素交换，则将标记变量 ​​isSwapper​​​ 赋值为 ​​true​​​。直到 ​​isSwapper​​​ 为 ​​false​​ 时，数组的里所有元素都处于正确的位置，此时可以结束遍历了。
• 根据执行结果可知，相比普通的算法，优化后的算法少了一轮遍历，这只是在数组元素少的情况下，如果在数组元素多的情况下，对比结果会更明显。
• 如果数组为 [5,1,2,3,4]，那么算法只会遍历一轮，就能得到正确的排序结果。因此优化后的算法，最好的情况下时间复杂度为 O(N)，最坏的情况下仍为 O(N²)。

小结

本文首先对冒泡排序进行简单的介绍，然后通过图片演示冒泡排序的思路。普通冒泡排序算法一共要遍历 n - 1 轮，由测试用例 [4 2 1 3 5] 的结果可以推断出 如果在一轮遍历中，没有进行元素交换位置的操作，那么此时数组的里所有元素都处于正确位置。 根据这个结论，对算法进行优化，优化后的算法，最好的情况下时间复杂度为 O(N)。