数组----冒泡排序和选择排序的 疑难杂问

今天学了一个数组的排序，里面有冒泡排序和选择排序。不知道你们，反正我今天是听着懂，轮到我自己写的时候，真的是酸爽无比啊！

好啦！接下来我们来说一下这两个排序方式。它们两个都是将数组中的数值,按照执行的顺序,从小到大排序

冒泡排序

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

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

                    优化: 
                        1, 单次循环,最后一个单元,通过倒数第二个单元,参与比较
                           最后一个单元,就不参与单次循环
                        2, 之前比较出的最大值,不再参与下一次的比较

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

                    核心: 交换存储的数据

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

冒泡排序

我们可以看一下这个动图，它的原理就是运用了冒泡排序的方法从数组的初始值也就是索引0开始进行比较，

第一次循环：从数组的第一项开始，让第一项与第二项进行大小的比较，当第一项大于第二项，第一项与第二项交换位置，且继续用原第一项与第三项进行比较大小；如果第一项和第二项进行比较时，第一项小于第二项，我们则用第二项继续与第三项尽行大小的比较。以此类推，我们会找到数组里面的最大值。

接着第二次循环，和第一次循环的原理一样。

下面我们看一个冒泡排序的代码：

        <script>
            var wjt = [3, 21, 3215432, 321321, 32, 43, 5, 34, 43, 23, 32543, 1234, 45, 321, 14, 234, 4];
            // 外层循环,循环执行排序操作,循环次数是数组单元个数-1
            for (var a = 0; a <= (wjt.length - 1) -1; a++) {
                // 内层循环,每次循环比较一个最大值
                // 上一次比较出的数值,不参与下一次循环 -j
                // 当次循环的最后一个单元,通过倒数第二个单元,参与比较不参与循环 -1
                for (var b = 0; b <= (wjt.length-1) -1 -a; b++) {
                    if(wjt[b] > wjt[b + 1]) {
                        // 交换存储的数据
                        var m = 0;
                        m = wjt[b];
                        wjt[b] = wjt[b + 1];
                        wjt[b + 1] = m;
                    }
                }
            }
            console.log(wjt);

        </script>

这是我们优化过后的代码哦！

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

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

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

 

运行结果：

 

选择排序

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

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

选择排序

 

 

我们可以看一下这个动图，它的原理就是运用了选择排序的方法从数组的初始值也就是索引0开始进行比较

 

        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);

运行结果：