冒泡排序算法

冒泡排序

算法说明与代码实现：

简单分析，外循环次数为数据len(arr)-1次，内循环为len(arr)-外循环次数

下面是使用Go语言实现冒泡排序算法的示例：

package main

import "fmt"

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]
			}
			// 从大到小
			//if arr[j] < arr[j+1] {
			//	arr[j], arr[j+1] = arr[j+1], arr[j]
			//}
		}
	}
}

func main() {
    // 待排序的数组
    arr := []int{7, 3, 22, 15, 8}

    fmt.Println("排序前:", arr)

    // 调用冒泡排序函数
    bubbleSort(arr)

    fmt.Println("排序后:", arr)
}

在上述示例中，我们定义了一个bubbleSort函数来实现冒泡排序算法。该函数接受一个整数切片作为输入，并对切片进行升序排序。冒泡排序的基本思想是通过不断交换相邻元素的位置来逐步将较大的元素推向数组的末尾。

在main函数中，我们定义了一个待排序的整数切片arr，并打印出排序前的切片内容。然后，我们调用bubbleSort函数对切片进行排序。最后，我们再次打印排序后的切片内容。

运行上述代码将输出以下结果：

排序前: [7 3 22 15 8]
排序后: [3 7 8 15 22]

可以看到，冒泡排序算法成功将切片按照升序进行了排序。请注意，冒泡排序的时间复杂度为O(n^2)，在处理大规模数据时可能效率较低。

图解过程：

分析描述：

1. 第一轮排序：22的位置被固定
   1. 7和3比较，若逆序则交换位置。因为7>3两数是逆序的，所以交换位置：7,3, 22,15,8 --> 3,7, 22,15,8
   2. 7和22比较，若逆序则交换位置。因为7<22两数是顺序的，所以不交换位置：3, 7, 22, 15,8 -->3, 7, 22, 15,8
   3. 22和15比较，若逆序则交换位置。因为22>15两数是逆序的，所以交换位置：3,7, 22,15, 8 --> 3,7, 15,22, 8
   4. 22和8比较，若逆序则交换位置。因为22>8两数是逆序的，所以交换位置：3,7, 15, 22,8 --> 3,7, 15, 8,22
      第一轮排序后的结果：【22的位置被固定】3,7, 15, 8,22
2. 第二轮排序：15的位置被固定
   1. 3和7比较若逆序则交换位置。因为3<7两数是顺序的，所以不交换位置：3,7, 15, 8,22 --> 3,7, 15, 8,22
   2. 7和15比较若逆序则交换位置。因为7<15两数是顺序的，所以不交换位置：3, 7, 15, 8,22 --> 3, 7, 15, 8,22
   3. 15和8比较若逆序则交换位置。因为15>8两数是逆序的，所以交换位置：3, 7, 15, 8,22 --> 3, 7, 8, 15,22
      第二轮排序后的结果：【15的位置被固定】3, 7, 8, 15, 22
3. 第三轮排序：8的位置被固定
   1. 3和7比较若逆序则交换位置。因为3<7两数是顺序的，所以不交换位置：3,7, 8, 15,22 --> 3,7, 8, 15,22
   2. 7和8比较若逆序则交换位置。因为7<8两数是顺序的，所以不交换位置：3, 7, 8, 15,22 --> 3, 7, 8, 15,22
      第三轮排序后的结果：【8的位置被固定】：3, 7, 8,15, 22
4. 第四轮排序：7的位置被固定
   1. 3和7比较若逆序则交换位置。因为3<7两数是顺序的，所以不交换位置：3,7, 8,15,22 --> 3,7, 8,15,22
      第四轮排序后的结果：【7的位置被固定】：3, 7, 8,15, 22