1.简介

冒泡排序（Bubble Sort）是一种较为简单的排序算法，重复的走访要排序的数列，一次比较两个元素，如果顺序错误就交换，走访舒蕾的工作是重复的进行指导没有需要再交换的位置，如同水中的气泡最终上浮到顶端一样。
冒泡排序（Bubble Sort）还有一种优化算法，就是立一个flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。

2.原理

以升序排序为例

比较相邻的元素，如果第一个比第二个大，就交换彼此；
对每一对相邻元素做同样的工作，从开始第一对结尾的最后一对，此时，最后打的元素应该是最大的数；针对所有元素重复以上步骤，除了最后一个；
持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较。

3.操作规则

外层控制行【控制比较次数】
内层控制列【控制交换次数】
相邻比大小
规则交换值

4.Golang代码

1.升序

// 冒泡排序--升序
func BubbleSortAsc(array []int) {// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {// 3.相邻比大小if array[j] > array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]}}}
}

2.降序

// 冒泡排序--降序
func BubbleSortDesc(array []int) {// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {// 3.相邻比大小if array[j] < array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]}}}
}

3.测试

func main() {array := []int{1, 3, 5, 9, 10, 2, 0, 7, 8, 4}fmt.Println("原数据：", array)BubbleSortAsc(array)fmt.Println("冒泡升序：", array)BubbleSortDesc(array)fmt.Println("冒泡降序：", array)
}

4.完整代码

package mainimport ("fmt"
)// 冒泡排序--升序
func BubbleSortAsc(array []int) {// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {// 3.相邻比大小if array[j] > array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]}}}
}// 冒泡排序--降序
func BubbleSortDesc(array []int) {// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {// 3.相邻比大小if array[j] < array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]}}}
}func main() {array := []int{1, 3, 5, 9, 10, 2, 0, 7, 8, 4}fmt.Println("原数据：", array)BubbleSortAsc(array)fmt.Println("冒泡升序：", array)BubbleSortDesc(array)fmt.Println("冒泡降序：", array)
}

5.优化

优化：

在某些数据元素已经有序的情况下，没必要进行操作，提高效率

1.原冒泡排序

操作次数统计count

package mainimport ("fmt"
)// 冒泡排序--升序
func BubbleSortAsc(array []int) {count := 0// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {count++// 3.相邻比大小if array[j] > array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]}}}fmt.Println("冒泡排序升序执行次数：", count)
}// 冒泡排序--降序
func BubbleSortDesc(array []int) {count := 0// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {count++// 3.相邻比大小if array[j] < array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]}}}fmt.Println("冒泡排序降序执行次数：", count)
}func main() {array := []int{1, 3, 5, 9, 10, 2, 0, 7, 8, 4}fmt.Println("原数据：", array)BubbleSortAsc(array)fmt.Println("冒泡升序：", array)BubbleSortDesc(array)fmt.Println("冒泡降序：", array)
}

原数据： [1 3 5 9 10 2 0 7 8 4]
冒泡排序升序执行次数： 45
冒泡升序： [0 1 2 3 4 5 7 8 9 10]
冒泡排序降序执行次数： 45
冒泡降序： [10 9 8 7 5 4 3 2 1 0]

2.优化后

package mainimport ("fmt"
)// 冒泡排序--升序
func BubbleSortAsc(array []int) {// 定义标记，如果已经连续，则不再执行doExec := falsecount := 0// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {count++// 3.相邻比大小if array[j] > array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]// 执行操作，置truedoExec = true}}// 如果没有进行比较交换，则直接退出，不再执行if !doExec {break} else {//如果已经进行比较交换了，那么恢复默认标记，方便后续比较doExec = false}}fmt.Println("冒泡排序升序执行次数：", count)
}// 冒泡排序--降序
func BubbleSortDesc(array []int) {// 定义标记，如果已经连续，则不再执行doExec := falsecount := 0// 1.外层控制行[控制比较的次数]：减1的操作，因为是两两相比，所以比较的次数是len-1for i := 0; i < len(array)-1; i++ {// 2.内层控制列[控制交换的次数]:减i的操作，因为随着i的增加，j的上限在减少for j := 0; j < len(array)-1-i; j++ {count++// 3.相邻比大小if array[j] < array[j+1] {// 4.规则交换值array[j], array[j+1] = array[j+1], array[j]// 执行操作，置truedoExec = true}}// 如果没有进行比较交换，则直接退出，不再执行if !doExec {break} else {//如果已经进行比较交换了，那么恢复默认标记，方便后续比较doExec = false}}fmt.Println("冒泡排序降序执行次数：", count)
}func main() {array := []int{1, 3, 5, 9, 10, 2, 0, 7, 8, 4}fmt.Println("原数据：", array)BubbleSortAsc(array)fmt.Println("冒泡升序：", array)BubbleSortDesc(array)fmt.Println("冒泡降序：", array)
}

原数据： [1 3 5 9 10 2 0 7 8 4]
冒泡排序升序执行次数： 42
冒泡升序： [0 1 2 3 4 5 7 8 9 10]
冒泡排序降序执行次数： 45
冒泡降序： [10 9 8 7 5 4 3 2 1 0]
同样的数据进行排序，执行的次数已经有了明显的优化

Golang(二十一)[排序算法-冒泡排序]相关推荐

python排序算法 ——冒泡排序（附代码）
python排序算法 --冒泡排序文章目录 python排序算法 --冒泡排序一.前言二.算法描述三.代码实现总结一.前言相关知识来自<python算法设计与分析>.初级排序 ...
十大经典排序算法-冒泡排序算法详解
十大经典排序算法十大经典排序算法-冒泡排序算法详解十大经典排序算法-选择排序算法详解十大经典排序算法-插入排序算法详解十大经典排序算法-希尔排序算法详解十大经典排序算法-快速排序算法详解十 ...
C语言基础排序算法-冒泡排序
C语言基础排序算法-冒泡排序什么是冒泡排序? 顾名思义,这种排序方法就像水中的气泡一样,从底逐渐往上冒,一次前进一步.我们来看一个例子,看看到底是怎么冒泡的.假设有一个数组3,2,5,4,1,我们希 ...
经典排序算法 - 冒泡排序Bubble sort
经典排序算法 - 冒泡排序Bubble sort 其原理是比较接近的数字22,按照从小到交换大或降序排列, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头開始进行两两比較交换,直到倒 ...
排序算法——冒泡排序(Bubble Sort)
排序算法--冒泡排序(Bubble Sort) 算法简介(Introduction) Bubble sort is to compare adjacent elements of the list a ...
数据结构--排序算法(冒泡排序)
一.原理冒泡排序是最简单的排序算法,两层遍历,外部循环从第一个元素开始遍历到倒数第二个,内部循环从最后一个元素遍历到外部循环的下一个元素,内部循环比较当前元素和前一个位置的元素,如果当前元素大,则交 ...
冒泡和快速排序的时间复杂度_java 八大排序算法冒泡排序快速排序堆排序归并排序等...
八大排序算法一.直接插入 1.基本思路在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的.如此反复循环 ...
经典排序算法----冒泡排序算法及其优化（稳定）
冒泡排序(稳定) 冒泡排序就是把小的元素往前调或者把大的元素往后调.比较是相邻的两个元素比较,交换也发生在这两个元素之间.所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的:如果两个相等的 ...
排序算法---冒泡排序（java版）
冒泡排序原理冒泡排序(Bubble Sort)是一种简单的排序算法,它通过依次比较两个相邻的的元素,看两个元素是否满足大小关系要求,如果不满足则交换两个元素.每一次冒泡会让至少一个元素移动到它应该 ...

Golang(二十一)[排序算法-冒泡排序]

Golang-排序算法-冒泡排序