JS冒泡排序的6种写法（武当雄风）

天下英雄出我辈，一入江湖岁月催。鸿图霸业谈笑间，不胜人生一场醉。
武当山上，一年一度的试道大会又开始了...
众武当弟子摩拳擦掌都想在此次试道大会上一展风采...
张三丰临终前曾留下一句话：试道大会采用冒泡排序....
冒泡思想：每冒泡一轮（外层for循环控制），选出这一轮中最大的数（内层for循环依次两两比较逐步移到最后...）
一共进行arr.length-1轮 (2个比一轮、3个比两轮、悟不出来自己收拾行李快快下山吧，我武当派没有你这样的弟子！)
每轮比较arr.length-1次？(因为每一轮冒泡得到的最大值已经得道成仙无需再比 所以每轮比较arr.length-1-i次)

灵魂版1(实力对决之一个都不能少)

由两位德高望重的裁判主持
主裁判（外层for循环）负责轮数，副裁判（内层for循环）在主裁判的指导下负责每一场比武...

    bubbleSortSoul1 = (arr = []) => {
        let count = 0;
        // i为轮数(因i从0开始 即i<arr.length-1)
        for (let i = 0; i < arr.length - 1; i++) {
            count++;
            // 第i轮仅需比较length-1-i次
            for (let j = 0; j < arr.length - 1 - i; j++) {
                // 这里能不能写成arr[j-1]>arr[j]? 如果有这种特殊癖好 那么j就从1开始吧，然后j<arr.length-i
                if (arr[j] > arr[j + 1]) {
                    let temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        console.log(`bubbleSortSoul1排序完成用了${count}轮`);
        return arr;
    }

灵魂版2(实力对决之换汤不换药)

副裁判突发奇想，竟悟出--心法，每轮比武不再需要主裁判详细指导(不用-i)

    bubbleSortSoul2 = (arr = []) => {
        let length = arr.length - 1;
        let count = 0;
        for (let i = 0; i < arr.length - 1; i++) {
            count++;
            // 这里的length第一轮==arr.length-1-0跟上一版一样
            for (let j = 0; j < length; j++) {
                if (arr[j] > arr[j + 1]) {
                    let temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            // 每一次内层for循环比较完成-1 跟前面的-i一样 换汤不换药
            length--;
        }
        console.log(`bubbleSortSoul2排序完成用了${count}轮`);
        return arr;
    }

灵魂版3(实力对决之副裁判独担重任)

主裁判临时有事请假，大会当头，副裁判迫于压力终悟出冒泡心经，大会依然有序进行...

    bubbleSortSoul3 = (arr = []) => {
        let length = arr.length - 1;
        let count = 0;
        // 单层for循环
        for (let j = 0; j < length; j++) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
            // 在循环到最大值时候重置j(j=-1到上面j++重置为0)这样可以省了外层for循环
            // 某弟子问:兄dei 这样也行？靠谱不？师傅知道你在瞎搞不？
            // 副裁判：好好比武别废话！冒泡心经！汝辈岂知？
            if (j == length - 1) {
                j = -1;
                length--;
                count++;
            }
        }
        console.log(`bubbleSortSoul3排序完成用了${count}轮`);
        return arr;
    }

没有灵魂版1(flag心法？比武可能提前结束)

师父得知副裁判在主裁判不在的情况下成功举行了一场大会，颇为高兴，决定传一套flag心法给副裁判
此次大会由主裁判弟弟while担任，弟弟毕竟是弟弟，知道的太少了，只能听从安排
副裁判对弟弟说:这样吧，等会比武我微信给你发true你就喊开始，发false你就喊结束，are you OK? 弟弟表示很OK
内幕:部分弟子比武期间被安排得明明白白？比武提前结束...

    bubbleSortNoSoul1 = (arr = []) => {
        let [length, flag, count] = [arr.length - 1, true, 0];
        // 这里用while执行轮数 (也可以用for)
        while (flag) {
            count++;
            // flag心法第一章:他强由他强 清风拂山岗 他横由他横 明月照大江
            // 副裁判准备马上微信给弟弟发false想要结束比武 刚打好没发出去 下面的弟子开始躁动了 干哈呢 比不比了？？
            // 好在副裁判有慧根 立即悟出原理(此次比完没有交换就结束吧 再比也没有意义了!)师父果然是师父!佩服！
            flag = false;
            // 大家安静 还是老规矩 继续...
            for (let j = 0; j < length; j++) {
                if (arr[j] > arr[j + 1]) {
                    let temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    // 如果此次循环有交换 则说明还得再来一轮，继续往下比...这轮结束就发true给弟弟
                    flag = true;
                }
            }
            length--;
        }
        console.log(`bubbleSortNoSoul1排序完成用了${count}轮`);
        return arr;
    }

没有灵魂版2(左右互博之术？副裁判得到周伯通真传)

while弟弟被逼做数学题，比大小
副裁判备受周伯通喜欢，习得左右互博之术，并将之发扬光大...

    bubbleSortNoSoul2 = (arr = []) => {
        let [j, temp, left, right, count] = [0, 0, 0, arr.length - 1, 0];
        while (left < right) {
            count++;
            for (j = left; j < right; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            right--;
            for (j = right; j > left; j--) {
                if (arr[j - 1] > arr[j]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
            left++;
        }
        console.log(`bubbleSortNoSoul2排序完成用了${count}轮`);
        return arr;
    }

没有灵魂版3(flag心法+左右互博)

这场比武让副裁判终成一代大侠...

    bubbleSortNoSoul3 = (arr = []) => {
        let [j, temp, left, right, flag, count] = [0, 0, 0, arr.length - 1, true, 0];
        while (left < right && flag) {
            count++;
            flag = false;
            for (j = left; j < right; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            right--;
            for (j = right; j > left; j--) {
                if (arr[j - 1] > arr[j]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                    flag = true;
                }
            }
            left++;
        }
        console.log(`bubbleSortNoSoul3排序完成用了${count}轮`);
        return arr;
    }

测试结果：

    let arr1 = [1, 2, 7, 8, 4, 5, 6, 3, 9];

    console.time('1');
    console.log(bubbleSortSoul1(arr1.concat()));  //8轮
    console.timeEnd('1');
    console.time('2');
    console.log(bubbleSortSoul2(arr1.concat()));  //8轮
    console.timeEnd('2');
    console.time('3');
    console.log(bubbleSortSoul3(arr1.concat()));  //8轮
    console.timeEnd('3');
    console.time('4');
    console.log(bubbleSortNoSoul1(arr1.concat()));//6轮
    console.timeEnd('4');
    console.time('5');
    console.log(bubbleSortNoSoul2(arr1.concat()));//4轮
    console.timeEnd('5');
    console.time('6');
    console.log(bubbleSortNoSoul3(arr1.concat()));//3轮
    console.timeEnd('6');

node环境下测试结果

注:

• 汝辈岂知。——《三国演义》孔明空城计，司马懿两个儿子要攻城，司马懿：汝辈岂知？宜速退。
• 他强由他强 清风拂山岗 他横由他横 明月照大江。——出自金庸《倚天屠龙记》里九阳真经。
• 周伯通。——金庸《射雕英雄传》人物，曾将空明拳和双手互博之术传给郭靖。