冒泡排序和选择排序(JavaScript)

冒泡排序

冒泡排序的原理：

相邻的两个单元比较存储的数据,如果前一个单元的数据较大,就将两个相邻单元数据内容进行交换。

示意图：

过程：

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

执行代码：

    var arr1=[6,8,3,5,2,10,1,9,4,7];    //定义数组1
    
    for(var i=0;i<arr1.length-1;i++){       //外层循环执行次数为元素个数-1

        for(var j=0;j<arr1.length-1-i;j++){     //最后两个元素位置已经确定不需要再比较  次数-1，
                                                //已经确定顺序的尾部元素不需要再次比较  次数-i  
            if(arr1[j]>arr1[j+1]){      //如果相邻元素 前面的比后面大 就交换两个元素的位置
                var middle=0;          
                middle = arr1[j];
                arr1[j] = arr1[j+1];
                arr1[j+1] = middle;
            }
        }
    }
    console.log(arr1);

代码优化：

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

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

2,外层循环优化 :

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

3,内层循环优化2 :

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

选择排序

选择排序的原理：

找到最小值的索引,与起始位置交换数值
如果最终存储的索引下标,不是起始位置,就与起始位置交换存储数据

示意图：

过程:

先定义循环的起始位置默认为最小值所在位置
从起始位置下一个位置开始,执行循环
如果当前位置上的数值小于存储索引位置上的数值，就存储当前位置的 索引值

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

再执行多次循环,完成排序

执行代码：

    var arr2=[6,9,3,1,5,2,8,7,4,10];  //定义数组2
    
    for(var i=0;i<arr2.length-1;i++){       //外层循环次数为元素个数-1
        var min = i;                        //把每次循环的当前位置作为起始的min
        for(var j=i+1;j<arr2.length;j++){   //当前起始位置元素挨个与后续元素比较，应该从当前元素+1往后循环
            if(arr2[min]>arr2[j]){            //如果当前比较的起始位置元素比后面某项元素大，那么min  
                min = j;                    // 不再记录当前起始元素的索引，此时记录小的那个值的索引下标
            }
        }
        if(min!=i){                         //循环一轮过后得到最小值元素下标 ，看看该下标是否在起始位置
            var temp=0;                     //如果不在，则交换起始位置下标与最小值下标元素的数据
            temp=arr2[i];
            arr2[i]=arr2[min];
            arr2[min]=temp;
        }
    }
    console.log(arr2);

代码优化：

1,之前比较出的数值不参与下一次比较
2,n个单元,只要比较n-1次(从起始位置的下一个位置开始循环)