冒泡排序详解、选择排序详解、数组去重四种方法以及数组塌陷

week2 day04

①冒泡排序

思路：
先遍历数组；
两两相比较，原理：比较两个相邻的元素，将值大的元素交换至右端。；
嵌套循环 外面控制几轮；
里面控制 每一轮多少次；


        var arr = [10, 198, 19, 99, 9, 11, 18, 1, 2, 5, 9];
        for (var i = 0; i <= arr.length - 1; i++) {   // 控制趟数
            for (var j = 0; j < arr.length - 1 - i; j++) {  // 控制几次
                if (arr[j] > arr[j + 1]) {   // 交换变量
                    var tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
        document.write(arr);

口决：
双层for循环 一层比上一层少一次
里层减外层 变量相交换

冒泡排序动态图

②选择排序

思路：
先找到数组内最小数字的索引
这个索引再跟下标0 交换
此时下标0 就是数组的最小值
跳过下标[0]
从下标[1] 到最后 找到最小值的索引
然后在跟下标[1] 交换
以此类推....


        var arr2 = [9, 3, 6, 10, 2, 5, 11, 4, 1, 7];
        // i          第几轮  假设最小的索引是  循环开始的位置下一个到最后  跟下标位置交换

        // j = 0       1       0                   1                       0

        // j = 1       2       1                   2                       1
        // j = 2       3       2                   3                       2

        for (var j = 0; j < arr2.length - 1; j++) {    // 外层循环 控制几轮
            var minIndex = j;   // 设置当前最小的索引
            for (var i = j + 1; i < arr2.length; i++) {     // 表示循环的位置一直到最后一个
                if (arr2[i] < arr2[minIndex]) {
                    minIndex = i;
                }
            }
            var temp = arr2[minIndex];  // 交换变量
            arr2[minIndex] = arr2[j];
            arr2[j] = temp;         
        }
   	document.write(arr2 + '
')

③数组塌陷 ———塌陷就是为了数组去重做铺垫

        var arr2 = [9, 3, 6, 10, 2, 5, 11, 4, 1, 7];

        // 第一种方法
        for (var i = 0; i < arr2.length; i++) {
            arr2.splice(i, 1);
            i--;
        }
        console.log(arr2)

        //第二种方法  --- 倒着删 
        for (var i = arr2.length - 1; i >= 0; i++) {
            arr2.splice(i, 1)
        }
        console.log(arr2)

④数组去重

      var arr2 = [9, 9, 3, 1, 9, 6, 10, 2, 5, 11, 4, 1, 7];

        // 第一种方案  思路 创建空数组  遍历数组  判断原数组元素不在空数组中
        var arr = [];
        for (var i = 0; i < arr2.length; i++) {
            if (arr.indexOf(arr2[i]) == -1) {
                arr.push(arr2[i]);
            }
        }
        console.log(arr)

        // 第二种方案 先排序 拿当前元素跟后一个进行比较  如果两个相同干掉一个

        arr2.sort(function (a, b) { return a - b });  // 排序以后的数组

        for (var i = 0; i < arr2.length; i++) {
            if (arr2[i] == arr2[i + 1]) {
                arr2.splice(i, 1);
                i--;
            }
        }
        console.log(arr2)

        // 第三种方案 直接遍历  如果 第一个后边 有跟第一个一样的 那么就删除

        for (var i = 0; i < arr2.length; i++) {
            var index = arr2.indexOf(arr2[i], i + 1);
            if (index !== -1) {
                arr2.splice(index, 1);
                i--;
            }

        }
        console.log(arr2)

        // 第四种 集合数据结构
        // 集合天生不接受重复数据
        // 集合中的数据一定是唯一的

        //  1、Array.from(集合)
        //  2、 ... 集合 相当于把集合的数据展开 三个点



        var res = Array.from(new Set(arr2));
        document.write(res);
        console.log(res)

        var res = [...new Set(arr2)];   // ... 用来展开数据
        document.write(res)