数组的冒泡排序和选择排序比较（逆战班）

数组的冒泡排序和选择排序比较


一、作用和原理：

 将数组中的数值,按照执行的顺序,从小到大排序。

 

二、核心内容：

1、冒泡排序：

原理: 相邻的两个单位,比较存储的数据，如果第一个单元的数据较大,就将两个相邻单元,交换存储数据。

（1）过程:

从起始单元开始比较,第一次循环,会选择出一个最大值,放在数组所有单元的最后，之后,每次循环,都会比较出一个本次循环的最大值,放在当前参与比较单元的最后，之前已经比较选出的单元,不会参与下一次比较。

（2）优化:

①单次循环,最后一个单元,通过倒数第二个单元,参与比较，最后一个单元,就不参与单次循环。

②之前比较出的最大值,不再参与下一次的比较。

③n个单元,只要循环比较n-1次,最后就一个单元时,不要再循环比较

核心: 交换存储的数据。两个相邻的单元,比较数据大小,第一个单元数值较大,就交换两个单元存储的数据。

 

2、选择排序：

（1）先定义循环的起始位置默认为最小值所在位置，从起始位置下一个位置开始,执行循环如果有位置上的数值,小于,存储索引位置上的数值，就存储这个位置的索引值，循环结束,比较存储的索引,是否是起始位置索引，如果不是,就交换两个位置上的数值，会将本次循环的最小值,放置在循环的起始位置上，再执行多次循环,完成排序。

（2）核心 : 找到最小值的索引,与起始位置交换数值，先找索引 在交换数值。

（3）优化 ：
①之前比较的数值不参与一次标记。

②n个单元,只要比较n-1次。

三、代码对比：
1、冒泡排列

 var arr = [5, 4, 3, 2, 1];

            // 通过for循环,实现排序
            // 每次循环,找到一个当前的最大值
            // 多次循环,完成排序

            // 程序的优化
            //   1,内层循环优化1 : 内层循环次数-1
            //       当前位和下一位比较 i 和 i+1 比较
            //       当前循环的倒数第二位,已经和最后一位进行比较
            //       当前循环的最后一位,只需要通过倒数第二位,参与比较
            //       不用参与循环

            //   2,外层循环优化 : 
            //       如果有n个单元参加排序,只需要循环排序n-1次
            //       最后一次循环排序,会将最后两个数值的大小排序确定
            //       剩下最后一个单元,没有循环排序,但是大小已经确定,不需要再次循环排序

            //   3,内层循环优化2 :
            //       上一次参与循环,已经决定出来的最大数值,不用参与下一次循环
            //       第一次排序,少0个单元参与
            //       第二次排序,少1个单元参与
            //       第三次排序,少2个单元参与
            //       ........
            //       通过外层循环变量,定义是从 0 开始的循环数值
            //       每次内层循环,次数,再减去 外层循环变量 的数值


            // 外层循环,循环执行排序操作,循环次数是数组单元个数-1
            for (var j = 0; j <= (arr.length - 1) - 1; j++) {

                // 内层循环,每次循环比较一个最大值
                // 上一次比较出的数值,不参与下一次循环 -j
                // 当次循环的最后一个单元,通过倒数第二个单元,参与比较不参与循环 -1
                for (var i = 0; i <= (arr.length - 1) - 1 - j; i++) {

                    if (arr[i] > arr[i + 1]) {
                        // 交换存储的数据
                        var middle = 0;
                        middle = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = middle;
                    }
                }
            }


            console.log(arr);

2、选择排列：

 // 选择排序
            //     从起始位置开始,找最小的数值所在的索引下标
            //     如果最终存储的索引下标,不是起始位置,就与起始位置交换存储数据
            //     执行一次循环,会将最小值存储在起始位置上
            //    
            //     下一次循环,之前的起始位置,不再参与循环
            //    
            // 外层循环:实现循环次数,是数组单元个数-1
            // 内层循环:每次循环,将本次循环找出来的最小值,与起始位置进行数值交换
            //         先默认起始位置的数值为最小值,存储起始位置的索引值
            //         之后从起始位置的下一个位置开始循环,生成之后的所有索引下标,
            //         如果之后位置上的数值,小于存储的索引位置的数值,就存储这个数值的索引
            // 循环结束,变量中存储本次内层循环选择出的最小值的索引下标
            // 进行比较判断,如果这个索引值,不是起始索引值,就交换两个索引值对应的数据

            // 程序的优化:
            //    外层优化:之前比较出的数值,不参与下一次的比较
            //    内层优化:从起始位置的下一个位置开始循环

            var arr = [3, 44, 38, 5, 47, 25, 36, 2, 79, 8, 1];
            // console.log(arr);

            // 外层循环,实现排序循环次数,次数是单元个数 -1
            for (var j = 0; j <= arr.length - 1 - 1; j++) {
                // 先默认起始位置就是最小值位置,存储起始位置的索引,也就是 j
                // 之前的起始位置,不参与下一次循环
                var min = j;

                // 默认的最小值位置是当前循环的起始位置,是j
                // 比较,要从下一个位置开始,内层循环起始,是比较的起始位置+1开始循环 
                for (var i = j + 1; i <= arr.length - 1; i++) {
                    // 如果有单元的数值,小于存储的索引对应的数值
                    if (arr[min] > arr[i]) {
                        // 变量中,存储当前较小值的索引下标
                        // 不是做数据交换,是存储这个数值位置的索引下标
                        min = i;
                    }
                }
                // 内层循环执行完毕,存储的索引下标如果不是起始的索引j
                // 就交换 min中存储的索引下标对应的数值 和 j索引下标应的数值
                if (min != j) {
                    var m = 0;
                    m = arr[j];
                    arr[j] = arr[min];
                    arr[min] = m;
                }
            }

            console.log(arr);

 

三、总结：

选择排序:

如果发生大小顺序问题,只是做赋值索引的操作，等循环完成,执行判断,做一次数据交换。

冒泡排序:

每次发生大小顺序问题,都要执行数据交换操作，执行数据交换的次数,高于选择排序。执行数据交换的操作比较繁琐,执行次数过多,执行效率低。