算法：冒泡排序及优化

前言

如果想深入了解的话建议先看看 算法概述

为了方便用来测试的数组一成不变，我们可以来一个随机数组

const arr = []
const arrLength = 11 //可以随机长度 Math.floor(Math.random() * 30) + 1
for (let i = 0; i < arrLength; i++) {
    arr.push(Math.floor(Math.random() * 99) + 1)
}
console.log(arr, 'arr')

算法描述

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

动图演示

代码实现

//冒泡
function bubbleSort(arr){
    const len = arr.length
    for(let i=0;i<len-1;i++){
        for(let j=0;j<len-1-i;j++){
            if(arr[j+1]<arr[j]){
                const tem = arr[j+1]
                arr[j+1] = arr[j]
                arr[j] = tem
            }
        }
    }
    return arr
}
console.log(bubbleSort(arr),'bubbleSort arr')

优化思考

上面的代码对比次数是固定的，如果还记得高中数学中的排列组合的话会发现 次数 count 和 数组长度 length

count = (length-1)*length/2

那么上面要怎么优化呢？

稍微思考后发现，假如在某次循环中发现没有发生位置交换，则可以说明此时已经排序完成了，后续的排序已经没有必要继续下去了

function bubbleSort(arr) {
  const len = arr.length
  let count = 0
  for (let i = 0; i < len - 1; i++) {
    let flag = 0
    for (let j = 0; j < len - i - 1; j++) {
      count++
      if (arr[j] > arr[j + 1]) {
        const tem = arr[j + 1]
        arr[j + 1] = arr[j]
        arr[j] = tem
        flag = 1
      }
    }
    if(flag===0) break
  }
  console.log(count, 'bubbleSort count')
  return arr
}
console.log(bubbleSort(arr),'bubbleSort arr')

多试几次，可以看到上面的操作次数 count 是不一样的，主要取决于数组的有序度

最坏情况下对比次数：count = (length-1)*length/2
最好情况下对比次数：count = length-1
评价情况下对比次数：count = (length-1)*(length+2)/4
由于是原地排序，所以空间复杂度是常数级

忽略以上结果中的常数，即可得出下面的结论

复杂度

最坏时间复杂度：O(n²)
最好时间复杂度：O(n)
评价时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：稳定