JavaScript基础--冒泡排序和选择排序

虽然数组里面有个sort()方法，可以对数值进行排序，很方便快捷，但是学习JS，为了锻炼逻辑思维，还是很有必要学习自己书写代码，实现排序效果的。

1. 冒泡排序

接下来讲的冒泡排序，以从小到大为例，从大到小与其相反即可。

1.1 原理

相邻的数据进行两两比较，小数放在前面，大数放在后面，这样一趟下来，最小的数就被排在了第一位，第二趟也是如此，以此类推，直到所有的数据排序完成。

现在以数列[5,4,3,2,1]来说明该排序的执行原理，如下：

//  let arr=[5,4,3,2,1]
//  原理解析：
                              第一轮比较 （比较次数4）
                第一轮第一次               4 5 3 2 1
                第一轮第二次               4 3 5 2 1
                第一轮第三次               4 3 2 5 1
                第一轮第四次               4 3 2 1 5

                              第二轮比较 （比较次数3）
                第二轮第一次               3 4 2 1 5
                第二轮第二次               3 2 4 1 5
                第二轮第三次               3 2 1 4 5

                              第三轮比较 （比较次数2）
                第三轮第一次               2 3 1 4 5
                第三轮第二次               2 1 3 4 5

                              第四轮比较（比较次数1）
                              1 2 3 4 5

根据以上解析，可以了解到冒泡排序本质上就是对相邻数据进行两两比较，然后根据需求进行从小到大排序或者从大到小排序。并且可以发现比较的轮数刚好等于数组长度减1，而每一轮比较的次数逐层递减，等于数组长度减去当前的轮数。

1.2 规律

冒泡排序每一轮排序，都可以找出一个较大的值，放在最后面

1.3 结论（重要）

① 比较的轮数：数组长度-1；

② 每一轮比较的次数：数组长度-当前轮数；

1.4 口诀

双层for循环，一层减一次，里层减外层，先判断再进行变量相交换，具体代码如下：

let arr = [5, 3, 36, 2, 25, 8, 1, 4, 0, 11];
for (var i = 0; i < arr.length - 1; i++) {  // 外层循环控制比较轮数
    for (var j = 0; j < arr.length - i; j++) { // 内层循环控制每轮比较的次数
        if (arr[j] > arr[j + 1]) { // 利用第三个变量temp比较交换，将大的数排在前面，小的放在后面
            var temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
        }
    }
}
console.log(arr);  // [0, 1, 2, 3, 4, 5, 8, 11, 25, 36]

利用冒泡排序的原理，使用以上代码，即可将数组中的数据进行从小到大排序了。若是要进行从大到小排序，只需将条件表达式中的“ > ”改成“ < ”即可。

2. 选择排序

2.1 原理

选择排序，其实是一种打擂台法（一挑众）：即选出一个位置，让这个位置上的数和后面所有的数进行比较，如果比较出大小就交换两个数的位置。

现在以数列[5,4,3,2,1]来说明该排序的执行原理，如下：

//  let arr=[5,4,3,2,1]
//  原理解析：
                           第一轮比较（比较次数4）选中位置为第一个数所在的位置
            第一轮第一次                4 5 3 2 1
            第一轮第二次                3 5 4 2 1
            第一轮第三次                2 5 4 3 1
            第一轮第四次                1 5 4 3 2
                           第二轮比较（比较次数3）选中位置为第二个数所在的位置
  
            第二轮第一次                1 4 5 3 2
            第二轮第二次                1 3 5 4 2
            第二轮第三次                1 2 5 4 3
                           第三轮比较（比较次数2） 选中位置为第三个数所在的位置
 
            第三轮第一次                1 2 4 5 3
            第三轮第二次                1 2 3 5 4

                           第四轮比较（比较次数1）选中位置为第四个数所在的位置
                                       1 2 3 4 5

根据以上解析，可以了解到选择排序的本质是选中一个位置，然后将位置上的数与其后面的所有数进行比较，然后根据需求进行从小到大排序或者从大到小排序。并且可以发现比较的轮数刚好等于数组长度减1，而每一轮比较的次数逐层递减，等于数组长度减去当前的轮数。

2.2 规律

每一轮都能选出一个最小(大）数，放在选中的位置上

2.3 结论

① 比较的轮数：数组长度-1；

② 每一轮比较的次数：数组长度-当前轮数；

1.4 口诀

双层for循环，一层减一次，里层减外层，先判断再进行变量相交换，具体代码如下：

let arr = [5, 3, 36, 2, 25, 8, 1, 4, 0, 11];
for (var i = 0; i < arr.length - 1; i++) { // 外层循环控制比较轮数
    for (var j = i+1; j < arr.length; j++) { // 内层循环控制每一轮比较的次数
        // i表示选中的位置  arr[i]表示位置上的元素
        // 原理：位置后面的所有数和该位置上的数进行比较
        if (arr[i] > arr[j]) {
            var temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp
        }
    }
}
console.log(arr);   // [0, 1, 2, 3, 4, 5, 8, 11, 25, 36]

利用选择排序的原理，使用以上代码，即可将数组中的数据进行从小到大排序了。若是要进行从大到小排序，只需将条件表达式中的“ > ”改成“ < ”即可。

3. 总结

冒泡排序和选择排序，主要是原理上的区别，具体实现排序效果的思路不太一致，但是都是借助双循环结果，进行两两比较，然后按照需求交换数据，完成从小到大或者从大到小排序。冒泡排序使用更多，需要着重理解和掌握。