版权声明：转载时请说明作者与出处 https://blog.csdn.net/qq_36145914/article/details/88554886

文章目录

• 前言
• 优化
• 对比
• 进一步优化
• 注意
• 附

若文章有任何纰漏或未涉及你想了解的内容，欢迎在评论提出，我会尽最快速度回复。

前言

冒泡排序是一种广为人知的排序方法，它的实现大致可以描述为“相邻元素两两比较，交换次序，每一轮交换决出当前最大/最小数，从而实现排序”
因为涉及两层循环，冒泡排序的最差时间复杂度为O（n²）。
而冒泡排序的最佳情况是，一次遍历，排序完毕，故其最好时间复杂度为O（n）。
但很多书籍在提到最好时间复杂度的同时，仅提供了原始冒泡排序。其在程序设计上并不能达到O（n），给很多初学者造成了困惑。
为达到O（n），我们需要对原始冒泡排序进行简单的优化

优化

对冒泡排序的优化很简单，只要在外层循环中加入flag量进行判断——若本轮遍历没有发生任何一次交换，则终止循环。
优化代码如下：

function bubbleSort(arr) {
let loopTimes = 0
for (let i = 0, len = arr.length; i < len; i++) {
let finished = true
for (let j = 0, len = arr.length - i - 1; j < len; j++) {
if (arr[j] > arr[j + 1]) {
finished = false;
temp = arr[j + 1]
arr[j + 1] = arr[j]
arr[j] = temp
}
}
loopTimes++;
if (finished)
break
}
return loopTimes
}

let arr = [2, 3, 9, 4, 5]
let res = bubbleSort(arr)
console.log('loopTimes:' + bubbleSort(arr))
console.log('the Array after sorting:' + arr)
​

对比

1. 未优化的循环次数：
   

2. 优化后的循环次数：
   

进一步优化

冒泡算法还能更进一步优化。使用pos位置量记录本次交换最远元素，避免遍历末尾已排好序的序列，减少遍历的总步数。

function bubbleSort(arr) {
let loopTimes = 0  // 循环计数器
let steps = 0 // 步数
let last = arr.length - 1;
for (let i = 0, len = arr.length; i < len; i++) {
let finished = true // flag
let pos = 0;
for (let j = 0, len = last; j < len; j++) {
if (arr[j] > arr[j + 1]) {
finished = false;
temp = arr[j + 1]
arr[j + 1] = arr[j]
arr[j] = temp
pos = j
}
steps++;
}
last = pos
loopTimes++;
if (finished)
break
}
console.log(steps)
return { loopTimes, steps }
}

let arr = [6, 4, 3, 5, 2, 1, 9, 10, 11, 12, 14, 15]
let res = bubbleSort(arr)

console.log('the Array after sorting:' + arr)
console.log('steps:' + res.steps)
console.log('loopTimes:' + res.loopTimes)

注意

上例中涉及到JS的存储方式问题，在JS中，引用类型如Array会在堆区申请内存空间。当将引用类型传入函数时，相当于申请一个指针指向相同的内存空间。对函数参数进行改动可能会影响原数组，具体规则如下：

function test(arr)
{
arr[0] = 1 // 改变内存空间中的数据
arr = [0,1,2,3] // 申请新的内存空间，不会影响原数组。
}
let arr = [-1]
test(arr)

如果你不希望当函数传入数组参数后，可能存在改变原内存空间的行为，你可以使用concat()方法拷贝值相同的临时数组，参与接下来的运算。

function test(arr)
{
let tempArr = array.concat()
.....
}

附

算法实现集合