基础算法-排序|冒泡排序

「本文已参与好文召集令活动，点击查看：后端、大前端双赛道投稿，2万元奖池等你挑战！」

三言两语

搞懂基础算法系列之排序算法-冒泡排序 关键点：时间复杂度：O(n^2)

解题思路

冒泡排序（升序），就是数组中的每个元素都与该元素后面所有的元素进行比较，如果该元素比后续元素大则互相交换，否则继续比较直到元素都比较完。

解题演示

题目：对数据进行排序[11, 6 , 38, 19, 10, 66, 17,56 ]

解题：

第一轮：11 6 38 19 10 66 17 56

• 第一次：Ary[0] = 11 ，与后续元素value都进行比较，11 > 6 那么进行交换，当前Ary[0] =6 ，

  交换后结果：6 11 38 19 10 66 17 56

• 第二次：Ary[0] =6，6<38，不交换，结果：6 11 38 19 10 66 17 56

• 第三次：Ary[0] = 6， 6<19，不交换，结果：6 11 38 19 10 66 17 56

• 第四次：Ary[0] = 6， 6<10 ，不交换，结果：6 11 38 19 10 66 17 56

• ... ...

第一轮结束后结果：6 11 38 19 10 66 17 56

第二轮：6 11 38 19 10 66 17 56

• 第一次：Ary[1] = 11 ,与后面元素value都进行比较，11< 38 ,不交换
• 第二次：Ary[1] = 11，11< 19 ,不交换
• 第三次：Ary[1] = 11, 11>10,交换，结果：6 10 38 19 11 66 17 56
• 第四次：Ary[1] = 10, 10<66 ,不交换
• ... ...

第二轮结束后结果：6 11 38 19 10 66 17 56

就是这样依次将最大的值跟后续的值比较，比较大都替换到后面

代码实现：

Golang版本

package main
​
import "fmt"
​
func main() {
  ary := []int{11, 6, 38, 19, 10, 66, 17, 56}
  // 冒泡排序
  sortBubble(ary)
}
​
// 冒泡排序 时间复杂度 O(n^2)
func sortBubble(ary []int) {
  for i := 0; i < len(ary)-1; i++ {
    for j := 0; j < len(ary)-i-1; j++ {
      if ary[i] >= ary[j] {
        ary[i], ary[j] = ary[j], ary[i]
      }
    }
  }
​
  for _, v := range ary {
    fmt.Print(v, ",")
  }
}

JavaScript版本

(() => {
    let ary = [11, 6, 38, 19, 10, 66, 17, 56];
    //冒泡排序
    sortBuble(ary);
})()
​
// 冒泡排序 时间复杂度O(n^2)
function sortBuble(ary) {
    for (let i = 0; i < ary.length - 1; i++) {
        for (let j = i + 1; j < ary.length - i - 1; j++) {
            if (ary[i] >= ary[j]) {
                let temp = ary[i];
                ary[i] = ary[j];
                ary[j] = temp;
            }
        }
    }
    console.log(ary);
}