忙里偷闲写个冒泡排序。

原理：比较相邻两个的元素大小，将值大的元素放到右边，值小的放在左边。

方法：首先比较前两个数，将小的数放在前面，将大数放在后面，然后是第2和第3个数，将小的放在前面，大数放在后面... 日复一日，直到比较到最后的两个数，直到全部排序完成。

注意：最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。

代码

func main() {
	arr := [...]int{79, 1, 90, 38, 76, 33, 17, 88}
	sortArr4(arr[:])
	fmt.Println("排序完成：", arr)
}

func sortArr4(arr []int) {
	fmt.Println("传入数组：", arr, "长度：", len(arr))
	arrCount := len(arr) - 1
	count, swapCount := 0, 0 //计算遍历了多少次,发生数据交换多少次
	for i := 1; i <= len(arr); i++ {
		index := 0
		fmt.Println("遍历第", i, "趟:")
		for j := 1; j <= arrCount; j++ {
			count ++
			if arr[j-1] > arr[j] {
				arr[j], arr[j-1] = arr[j-1], arr[j]
				swapCount ++
				index = j - 1
				fmt.Println("发生了交换，index=", index)
			}
			fmt.Println("\t\t遍历第", j, "次:", arr)
		}
		arrCount = index
             // 没有位置变化说明无需再遍历，有效减少遍历和数据交换次数
		if arrCount == 1 {
			break
		}
	}
	fmt.Println("共发生数据交换：", swapCount, "次. 共遍历", count, "次。")
}

输出如下

传入数组： [79 1 90 38 76 33 17 88] 长度： 8
遍历第 1 趟:
		遍历第 1 次: [1 79 90 38 76 33 17 88]
		遍历第 2 次: [1 79 90 38 76 33 17 88]
		遍历第 3 次: [1 79 38 90 76 33 17 88]
		遍历第 4 次: [1 79 38 76 90 33 17 88]
		遍历第 5 次: [1 79 38 76 33 90 17 88]
		遍历第 6 次: [1 79 38 76 33 17 90 88]
		遍历第 7 次: [1 79 38 76 33 17 88 90]
遍历第 2 趟:
		遍历第 1 次: [1 79 38 76 33 17 88 90]
		遍历第 2 次: [1 38 79 76 33 17 88 90]
		遍历第 3 次: [1 38 76 79 33 17 88 90]
		遍历第 4 次: [1 38 76 33 79 17 88 90]
		遍历第 5 次: [1 38 76 33 17 79 88 90]
		遍历第 6 次: [1 38 76 33 17 79 88 90]
遍历第 3 趟:
		遍历第 1 次: [1 38 76 33 17 79 88 90]
		遍历第 2 次: [1 38 76 33 17 79 88 90]
		遍历第 3 次: [1 38 33 76 17 79 88 90]
		遍历第 4 次: [1 38 33 17 76 79 88 90]
遍历第 4 趟:
		遍历第 1 次: [1 38 33 17 76 79 88 90]
		遍历第 2 次: [1 33 38 17 76 79 88 90]
		遍历第 3 次: [1 33 17 38 76 79 88 90]
遍历第 5 趟:
		遍历第 1 次: [1 33 17 38 76 79 88 90]
		遍历第 2 次: [1 17 33 38 76 79 88 90]
共发生数据交换： 15 次. 共遍历 22 次。
排序完成： [1 17 33 38 76 79 88 90]

黄昏时偷来你的肋骨酿酒  百年后醉得有血有肉