JavaScript中的冒泡排序和选择排序

冒泡排序
原理：
　　相邻的两个单位，比较存储的数据
　　如果第一个单元的数据较大，就将两个相邻单元交换存储数据

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

优化：
　　1, 单次循环，最后一个单元，通过倒数第二个单元，参与比较，最后一个单元就不参与单次循环
　　2, 之前比较出的最大值，不再参与下一次的比较
　　3, n个单元，只要循环比较n-1次，最后就一个单元时，不要再循环比较

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

    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);     //[1, 2, 3, 4, 5]

 

选择排序

先定义循环的起始位置默认为最小值所在位置

从起始位置下一个位置开始，执行循环
如果有位置上的数值 小于 存储索引位置上的数值
就存储这个位置的索引值

循环结束，比较存储的索引,是否是起始位置索引
如果不是，就交换两个位置上的数值
会将本次循环的最小值，放置在循环的起始位置上
再执行多次循环，完成排序

核心：
　　找到最小值的索引，与起始位置交换数值
　　先找索引，再交换数值

        var arr = [3,44,38,5,47,25,36,2,79,8,1];

        // 外层循环,实现排序循环次数,次数是单元个数 -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);    //[1, 2, 3, 5, 8, 25, 36, 38, 44, 47, 79]

 

区别

选择排序：
　　如果发生大小顺序问题，只是做赋值索引的操作
　　等循环完成，执行判断，做一次数据交换
冒泡排序：
　　每次发生大小顺序问题，都要执行数据交换操作
　　执行数据交换的次数，高于选择排序
　　执行数据交换的操作比较繁琐,执行次数过多，执行效率低

 

逆战班