01 冒泡排序

原理：循环遍历数组

当前单元和下一个单元进行数据比较，按照从小到大排序（即当前单元小于下一个单元）

主要操作：如果当前单元大于下一个单元，将交换两个单元存储的数据

一次循环结束，会讲一个最大值存储到数组末位

核心优化：

内层优化：

   1、 当前单元 和 下一个单元 进行 数据比较

        最后一个单元 没有 下一个单元 进行 数据比较

        内层循环 是 从 数组的第一个单元 循环至 循环循环的 倒数第二个单元

    2, 上一次排序排序出最大值 不参与 下一次的循环排序

    也就是

    第一次 是 1-9 单元排序 少排序 0 个单元

    第二次 是 1-8 单元排序 少排序 1 个单元

    第三次 是 1-7 单元排序 少排序 2 个单元

    第四次 是 1-6 单元排序 少排序 3 个单元

    .....

    少排序的单元个数 0 1 2 3 4...

    正好对应 外层循环变量的数值

外层优化：

    1、 最后一个单元 没有 单元 进行 数据比较

    也就是 n 个 单元 只需要 循环 n-1 次 就可以 完成排序


<script>
        var arr = [10, 20, 30, 40, 31, 53, 22, 50]; 
        var n = 11; arr.push(n); 
        // console.log(arr); 
        for(var k = 0; k < arr.length - 1; k++){ 
            for(var i = 0; i < arr.length - 1 - k; i++){ 
                if(arr[i] > arr[i+1]){ 
                    var temp = arr[i]; 
                    arr[i] = arr[i + 1]; 
                    arr[i + 1] = temp; 
        } 
            } 
                } 
       console.log(arr); 
 </script>

02 选择排序

原理：

每次使用变量存储 起始循环单元的索引下标

使用 变量中存储的索引下标 对应的数值数值

和 之后的其他单元的数据数值进行比较

如果 之后循环单元数据数值 小于 变量中存储索引下标 对应的数据数值

变量 存储 循环单元的索引下标

循环结束 变量中存储本次循环 存储最小值单元的索引下标

如果 变量储存的索引下标 不是 起始单元的索引下标

交换两个单元存储的数据数值

每次循环 会将 最小值 存储到数组的起始位置

多次循环 完成 整个数组的排序

    <script> 
        var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]; 
        for(var k = 0; k < arr.length; k++){ 
            var minIndex = k; 
            for(var i = k + 1; i < arr.length; i++){ 
                if(arr[minIndex] > arr[i]){ 
                    minIndex = i; 
                } 
            } 
            var temp = arr[k]; 
            arr[k] = arr[minIndex]; 
            arr[minIndex] = temp; 
      } 
      console.log(arr); 
   </script>

03 数组的操作方法

04 数组塌陷

<script> 
    var arr = [1, 2, 3, 4, 5, 6]; 
    for(var i = 0; i < arr.length; i++){ 
        arr.splice(i, 1); 
        i--; ***** 
    } 
    console.log(arr);
</script>