排序之冒泡排序

话不多说先上代码

package main

import "fmt"

func bubleSort(arr *[5]int) {
	for i := 0; i < len(arr)-1; i++ {
		for j := 0; j < len(arr)-1-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
		fmt.Printf("第%d趟排序后的结果是: %d\n", i+1, *arr)

	}
	fmt.Println("bubleSort = ", *arr)
}

func main() {
	var arr [5]int = [5]int{8, 10, 7, 5, 3}
	bubleSort(&arr)
	fmt.Println("arr = ", arr)
}

结果是

第1趟排序后的结果是: [8 7 5 3 10]

第2趟排序后的结果是: [7 5 3 8 10]

第3趟排序后的结果是: [5 3 7 8 10]

第4趟排序后的结果是: [3 5 7 8 10]

bubleSort = [3 5 7 8 10]

今天这篇排序太敷衍了，本来还有一个简单选择排序要写的，但是想想还是早点休息

冒泡排序的过程：

相邻的两个位置的数字不断进行比较，满足条件则交换，一趟排序好一个数据

注意是相邻的两个位置的数字，我个人理解觉得这样要稍微好理解点

五个int，排序4趟即可

假设数组里面有五个数字，我们要按照从小到大的顺序排序

8, 10, 7, 5, 3

第一趟 第一次比较

拿第一个位置和第二个位置的数据比较

8和10比，如果8>10则交换，但是不满足条件所以8不和10交换

第一趟 第一次比较结果是 8, 10, 7, 5, 3

第一趟 第二次比较

拿第二个位置和第三个位置的数据比较

10和7比，如果10>7则交换，满足条件所以10和7交换

第一趟 第二次比较结果是 8, 7, 10, 5, 3

第一趟 第三次比较

拿第三个位置和第四个位置的数据比较

10和5比，如果10>5则交换，满足条件所以10和5交换

第一趟 第三次比较结果是 8, 7, 5, 10, 3

第一趟 第四次比较

拿第四个位置和第五个位置的数据比较

10和3比，如果10>3则交换，满足条件所以10和3交换

第一趟 第四次比较结果是 8, 7, 5, 3, 10

至此我们发现，第一趟选出了最大的10，放到了最右边

现在的数据是 8， 7， 5， 3， 10

再来一趟~

第二趟 第一次比较

拿第一个位置和第二个位置的数据比较

8和7比，如果8>7则交换，满足条件所以8和7交换

第二趟 第一次比较结果是 7, 8, 5, 3, 10

第二趟 第二次比较

拿第二个位置和第三个位置的数据比较

8和5比，如果8>5则交换，满足条件所以8和5交换

第二趟 第二次比较结果是 7, 5, 8, 3, 10

第二趟 第三次比较

拿第三个位置和第四个位置的数据比较

8和3比，如果8>3则交换，满足条件所以8和3交换

第二趟 第三次比较结果是 7, 5, 3, 8, 10

至此我们发现，第二趟选出了剩余数字里面最大的8，放到了10的左边

第二趟我们就不需要再和10比了，因为第一趟已经确定了10是最大的，而且它已经被放到最右边，所以后面的就可以少判断一次

现在的数据是 7， 5， 3， 8， 10

。。。。。。

经过多次排序直到我们需要的结果

我们可以发现，一共进行四趟排序

第一趟排序需要进行四次比较

第二趟排序需要进行三次比较

第三趟排序需要进行二次比较

第四趟排序需要进行一次比较

就需要总结下规律了，n个数据进行冒泡排序，

需要进行 n-1 趟排序，每趟排序的比较次数比上一趟少一次

这个时候再看看代码就明白了

冒泡排序比较简单，性能也比较低，就当是给我数据结构一个开端了，好低端，弟弟开局