冒泡排序和选择排序

本周逆战班学习了js 算法方面的，
冒泡排序

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

        // 外层循环,循环执行排序操作,循环次数是数组单元个数-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);

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

程序的优化

• 1,内层循环优化1 : 内层循环次数-1

         当前位和下一位比较 i 和 i+1 比较
         当前循环的倒数第二位,已经和最后一位进行比较
         当前循环的最后一位,只需要通过倒数第二位,参与比较
         不用参与循环
  

• 2,外层循环优化 :

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

• 3,内层循环优化2 :

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

冒泡排序总结:

• 核心: 相邻两个单元,比较数值大小,如果触发条件就交换存储数值

• 优化: 内层优化1: 只循环至倒数第二个单元,通过i+1,跟最后一个单元比较

内层优化2: 之前比较出的最大值,不再参与下一次的比较
外层优化 : n个单元,只循环n-1次,最后只剩一个单元时,不用循环

选择排序

 var arr = [3,2123,12,23,1,321,213];

        for(var i = 0 ; i <= arr.length-1 -1 ; i++){
            var min = i;
            for(var j = i+1 ; j <= arr.length-1 ; j++){
                if(arr[min] > arr[j] ){
                    min = j;
                }
            }

            if(min != i){
                var m = 0;
                m = arr[min];
                arr[min] = arr[i];
                arr[i] = m;
            }
        }

        console.log(arr);

选择排序WW
从起始位置开始,找最小的数值所在的索引下标
如果最终存储的索引下标,不是起始位置,就与起始位置交换存储数据
执行一次循环,会将最小值存储在起始位置上
下一次循环,之前的起始位置,不再参与循环

• 外层循环:实现循环次数,是数组单元个数-1

• 内层循环:每次循环,将本次循环找出来的最小值,与起始位置进行数值交换

• 先默认起始位置的数值为最小值,存储起始位置的索引值

• 之后从起始位置的下一个位置开始循环,生成之后的所有索引下标,

• 如果之后位置上的数值,小于存储的索引位置的数值,就存储这个数值的索引

循环结束,变量中存储本次内层循环选择出的最小值的索引下标

• 进行比较判断,如果这个索引值,不是起始索引值,就交换两个索引值对应的数据
  程序的优化:
  外层优化:之前比较出的数值,不参与下一次的比较
  内层优化:从起始位置的下一个位置开始循环