JavaScript array of bubble sort, selection sort

Bubble Sort

Bubble sort works:

相邻的两个单位,比较存储的数据
如果第一个单元的数据较大,就将两个相邻单元,交换存储数据
从起始单元开始比较,第一次循环结束,会选择出一个最大值,放在数组所有单元的最后
之后,每次循环结束,都会比较出一个本次循环的最大值,放在当前参与比较单元的最后

Bubble sort specific process:

第一次循环，相邻的两个单位进行比较,arr[0]和arr[1]比较，arr[1]和arr[2]比较,.....，arr[n-2]和arr[n-1]比较
第一次循环结束,会选择出一个最大值，在数组的最后
如果有n个单元参加排序,只需要排序n-1次，第n-1次排序,会将最后两个数值的大小排序确定
第二次循环，相邻的两个单位进行比较,arr[0]和arr[1]比较，arr[1]和arr[2]比较,.....，arr[n-3]和arr[n-2]比较
第二次循环结束,会选择出一个最大值，在数组的倒数第二位，之前已经比较选出的单元,不会参与下一次比较
所以第二次循环执行了n-2次，以此类推
···
数组中有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);

Selection Sort

Select Sort principle:

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

Select the sort specific process:

第一次循环，记录起始位置的索引为0，由起始位置依次和各个位置比较，n个单元，只要比较n-1次
如果有比记录位置小的，就将索引赋值给记录，
将记录的索引和起始索引比较，如果不是起始位置,就与起始位置交换存储数据，这时数组中的最小值在第一位
第二次循环，记录起始位置的索引为1，数组中第二小的数值在第二位
第三次循环，记录起始位置的索引为2，数组中第三小的数值在第三位
之前确定的位置，不参与下一次循环
···
最后一次循环，记录起始位置的索引为n-2，n个数值只要循环n-1次

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