排序
- 排序：把某个乱序的数组变成升序或降序的数组 (这里用数组来做举例)
冒泡排序
- 该排序属于 贪心 策略
- 关注的是局部，是一种苟且的东西
算法实现
1 ）version 1 初始版本
js
Array.prototype.bubbleSort = function() {
let len = this.length;
for(let i =0; i<len; i++) {
for(let j=0;j<len-1-i;j++) {
if(this[j] > this[j+1]) {
let tmp = this[j];
this[j] = this[j+1];
this[j+1] = tmp;
}
}
}
}
let arr = [5,4,3,2,1]
arr.bubbleSort()
console.log(arr); // [1, 2, 3, 4, 5]2 ） version 2 ES6 做两数交换 优化版
js
Array.prototype.bubbleSort = function() {
let len = this.length;
for(let i =0; i<len; i++) {
for(let j=0;j<len-1-i;j++) {
if(this[j] > this[j+1]) {
[this[j], this[j+1]] = [this[j+1], this[j]] // ES6 交换
}
}
}
}
let arr = [5,4,3,2,1]
arr.bubbleSort()
console.log(arr); // [1, 2, 3, 4, 5]3 ） version 3 冒泡排序，提前终止版
js
Array.prototype.bubbleSort = function() {
let len = this.length;
let sorted = false; // 哨兵变量
while(!sorted) {
sorted = true; // 提前终止标识
for(let i=0; i<len-1; i++) {
if(this[i] > this[i+1]) {
[this[i], this[i+1]] = [this[i+1], this[i]]
sorted = false;
}
}
// 如果经过上面一轮 sorted仍为true，没有变为false, 说明已经整体已经有序，可以提前终止了
len --;
}
}
let arr = [5,4,3,2,1]
arr.bubbleSort()
console.log(arr); // [1, 2, 3, 4, 5]4 ）version 4 冒泡排序，跳跃版
js
Array.prototype.bubbleSort = function() {
let len = this.length;
let k = len - 1; // 跳跃标识
let last = 0; // 内层循环标识
let i = 0;
// 第一层循环表示经过n-1趟扫描即可，每比较一趟，问题规模缩小1级，第一层循环次数必须不变 n-1 次
while(i<len-1) {
// 第二层循环表示每一趟进行两两逐个比较，找到最大的元素
for(let j=0; j<k; ++j) {
// 当前元素和后一个元素进行比较，若逆序
if(this[j]>this[j+1]) {
// 则交换
[this[j], this[j+1]] = [this[j+1], this[j]];
// 更新交换的位置
last = j;
}
}
// 在一层循环之后跳跃到最后交换的那个地方，这样的话，在k的位置，后面如果是有序，就可以直接跳过了
k = last;
++i;
}
}
let arr = [5,4,3,2,1]
arr.bubbleSort()
console.log(arr); // [1, 2, 3, 4, 5]5 ）version 5 冒泡排序，提前终止+跳跃版
js
Array.prototype.bubbleSort = function() {
let len = this.length;
let k = len - 1; // 跳跃标识
let last = 0; // 内层循环标识
let i = 0; // 最外层循环标识
let sorted = false; // 哨兵变量
// 第一层循环表示经过n-1趟扫描即可，每比较一趟，问题规模缩小1级，第一层循环次数必须不变 n-1 次
while(i<len-1 && !sorted) {
sorted = true;
// 第二层循环表示每一趟进行两两逐个比较，找到最大的元素
for(let j=0; j<k; ++j) {
// 当前元素和后一个元素进行比较，若逆序
if(this[j]>this[j+1]) {
// 则交换
[this[j], this[j+1]] = [this[j+1], this[j]];
// 更新交换的位置
last = j;
sorted = false;
}
}
// 在一层循环之后跳跃到最后交换的那个地方，这样的话，在k的位置，后面如果是有序，就可以直接跳过了
k = last;
++i;
}
}
let arr = [5,4,3,2,1]
arr.bubbleSort()
console.log(arr); // [1, 2, 3, 4, 5]- 冒泡排序最简单，性能不好，工作中用不到
- 思路
- 比较所有相邻元素，如果第一个比第二个大，则交换他们
- 一轮下来，可以保证最后一个数是最大的
- 执行n-1轮就可以完成排序了
- 我们可以看到每一轮循环是不一样的，执行区间越来越短
- 冒泡排序是一种贪心策略
- 动画示例：visualgo.net/zh/sorting
- 时间复杂度：O( n 2 n^2 n2)
- 两个嵌套循环
- 总结
- 该算法通过两两比较盯住当前最大的元素，逐渐将其移动到最后，继而一次有序，逐次比较达到整个序列完全有序
- 不变性：经k趟扫描交换后，最大的k个元素必然就位
- 单调性：经k趟扫描交换后，问题规模缩减至n-k
- 正确性：经至多n趟扫描后，算法必然终止，且能给出正确解答
- 它的核心思想是自左至右，逐一检查各对相邻元素，若有逆序，则交换
- 这个算法其实只需要经过n-1趟比较就足够了, 有改进的空间
- 如果某一趟比较后整体已经有序了，就没有必要继续比较到n-1趟了，即提前终止版
- 也许一个算法的思想在一开始是基于很low的策略，比如greedy
- 当基于这个greedy的算法不断做优化, 也能表现的非常好
- 一共有4个版本的写法(上面 1,2是一种，所以是4种)