js 的数组

1.冒泡排序

      是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，

      根据自身大小一点一点向数组的一侧移动

      冒泡排序的原理：

      每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。

      而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面两个相邻的两个数大小关系，重复此步骤，直到最后一个还没归位的数。

      基础版

         for (var k = 0; k < arr.length; k++) {

             for (var i = 0; i < arr.length; i++) {

                 if (arr[i] > arr[i + 1]) {

                     var temp = arr[i]

                     arr[i] = arr[i + 1]

                     arr[i + 1] = temp

                 }

             }

         }

         var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]

         // 下标    0  1  2  3   4  5  6  7  8

         console.log('原始数组: ', arr)

        // 优化1

         for (var k = 0; k < arr.length; k++) {

             for (var i = 0; i < arr.length - 1; i++) {

                 if (arr[i] > arr[i + 1]) {

                     var temp = arr[i]

                     arr[i] = arr[i + 1]

                     arr[i + 1] = temp

                 }

             }

         }

        // 优化2

          k == 0 第 1 次循环 确定了 [8] 的值

          k == 1 第 2 次循环 确定了 [7][8] 的值

          k == 2 第 3 次循环 确定了 [6][7][8] 的值

          k == 3 第 4 次循环 确定了 [5][6][7][8] 的值

          k == 4 第 5 次循环 确定了 [4][5][6][7][8] 的值

          k == 5 第 6 次循环 确定了 [3][4][5][6][7][8] 的值

          k == 6 第 7 次循环 确定了 [2][3][4][5][6][7][8] 的值

          k == 7 第 8 次循环 确定了 [1][2][3][4][5][6][7][8] 的值

          k == 8 第 9 次循环 确定了 [0][1][2][3][4][5][6][7][8] 的值

         for (var k = 0; k < arr.length - 1; k++) {

             for (var i = 0; i < arr.length - 1; i++) {

                 if (arr[i] > arr[i + 1]) {

                     var temp = arr[i]

                     arr[i] = arr[i + 1]

                     arr[i + 1] = temp

                 }

             }

         }

        // 优化3

        for (var k = 0; k < arr.length - 1; k++) {

            console.log(`这是第 ${k + 1} 轮循环(k == ${k})`)

            for (var i = 0; i < arr.length - 1 - k; i++) {

                console.log(arr[i], arr[i + 1])

                if (arr[i] > arr[i + 1]) {

                    var temp = arr[i]

                    arr[i] = arr[i + 1]

                    arr[i + 1] = temp

                }

            }

        }

         console.log('冒泡排序结束后的arr: ', arr)

2.变量提升

        变量提升通常发生在 var 声明的变量里，使用var声明一个变量时，该变量会被提升到作用域的顶端，但是赋值的部分并不会被提升。

3.选择排序

        选择排序的原理：

        选择排序在开始的时候，先扫描整个列表，以找到列表中的最小元素，然后将这个元素与第一个元素进行交换。这样最小元素就放到它的最终位置上。然后，从第二个元素开始扫描，找到n-1个元素中的最小元素，然后再与第二个元素进行交换。以此类推，直到第n-1个元素(如果前n-1个元素都已在最终位置，则最后一个元素也将在最终位置上)。

        选择排序的基本思想是：

        每一趟在n − i + 1 ( i = 1 , 2 , . . . , n − 1 ) 个元素中选择最小的元素，并将其作为有序序列中第 i 个元素。

        * 选择排序

        var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]

        // 下标    0  1  2  3  4  5  6  7  8

        console.log('原始数组arr: ', arr)

        /**

         *          第几次循环   假设谁是最小值     和谁交换    循环开始的值

         *  k == 0      1               0           0               1

         *  k == 1      2               1           1               2

         *  k == 2      3               2           2               3

         *  

        */

        for (var k = 0; k < arr.length; k++) {

            var minIndex = k    // 假设当前最小数值 为 下标 0 的项

            for (var i = k + 1; i < arr.length; i++) {

                if (arr[minIndex] > arr[i]) {

                    minIndex = i

                }

            }

            // 交换 真实最小的值  与 下标 0 的值

            var temp = arr[k]

            arr[k] = arr[minIndex]

            arr[minIndex] = temp

        }

        console.log('选择排序结束后的 arr: ', arr)

 

        // 第二轮

         var minIndex = 1    // 假设当前最小数值为 下标 1 的项

         for (var i = 2; i < arr.length; i++) {

             if (arr[minIndex] > arr[i]) {

                 minIndex = i

             }

         }

         // 交换 真实 最小的值 与 下标 1 的值

         var temp = arr[1]

         arr[1] = arr[minIndex]

         arr[minIndex] = temp

         console.log('第二轮 选择排序结束后的 arr: ', arr)

         // 第三轮

         var minIndex = 2

         for (var i = 3; i < arr.length; i++) {

             if (arr[minIndex] > arr[i]) {

                 minIndex = i

             }

         }

        // 交换 真实 最小的值 与 下标 2 的值

         var temp = arr[2]

         arr[2] = arr[minIndex]

         arr[minIndex] = temp

         console.log('第三轮 选择排序结束后的 arr: ', arr)

4.数组的方法

        数组的方法 1~7 是能够改变原数组的方法

        1. push;

              语法: 数组.push(数据)

              作用: 向 数组末尾 添加数据

              返回值: 追加数据后, 数组最新的长度

        2. pop;

              语法: 数组.pop()

              作用: 删除数组的最后一项

              返回值: 删除的哪一项数据

        3. unshift;

              语法: 数组.unshift(数据)

              作用: 向 数组头部 添加数据

              返回值: 追加数据后, 数组最新的长度

        4. shift;

              语法: 数组.shift()

              作用: 删除数组头部(第一项)的数据

              返回值: 删除的哪一项数据

        5. reverse;

              语法: 数组.reverse()

              作用: 反转数组

              返回值: 反转后的数组

          6. sort;

              语法: 数组.sort(); 数组.sort(function (a, b) {retrun a - b}); 数组.sort(function (a, b) {retrun b - a})

              作用:

                  不传参数

                      会将数组内所有值, 转换为字符串, 然后一位一位的对比(第一位相同,对比第二位,...)

                  传参---函数 return a - b

                      会将数组内所有的值, 按照数字的 从小到大排列

                  传参---函数 return b - a

                      会将数组内所有的值, 按照数字的 从大到小排列

              返回值:

                  不传参数

                      将排序后的数组返回

                  传递参数

                      将排序后的数组返回

        7. splice;

              语法: 数组.splice(开始索引, 多少个);  数组.splice(开始索引, 多少个, 数据1, 数据2, 数据3...)

              作用:

                  不传参数: 剪切数组中的某一段数据

                  传递参数: 剪切数组中的某一段数据, 将第三个参数开始, 当成新数据插入到数组内

              返回值: 截切后的数据(数组形式)

        8. slice;   (不会改变原数组)

              语法: 数组.slice(开始索引, 结束索引)

              参数特点: 1. 包含开始索引, 不包含结束索引(到结束索引前一位)

                       2. 参数接受负数(相当于 数组.length + 负数)

                       3. 不传结束索引     相当于写了 数组.length

                       4. 一个参数都不传   相当于复制整个数组, 或者只传递第一个参数为 0

              作用: 复制数组中的某一段数据

              返回值: 复制出来的内容

        9. concat;

              语法: 数组.concat(数据1, 数据2)

              作用: 将 参数, 合并到 指定数组内(如果参数写了数组, 那么会将数组的每一个值合并到指定数组)

              返回值: 合并后的数组

        10. join;

              语法: 数组.join(连接符)

                  参数可以不传, 不传递默认按照 , 逗号

              作用: 通过连接符连接数组的每一个值

              返回值: 连接好的数组

        11. indexOf;

              语法: 数组.indexOf(数据);   数组.indexOf(数据, 开始索引)

              作用: 在数组内寻找指定数据

              返回值:

                  1. 找到数据的时候, 返回数据第一次出现的下标

                  2. 找不到的时候, 返回 -1

        12. lastIndexOf

              语法: 数组.lastIndexOf(数据);   数组.lastIndexOf(数据, 开始索引)

              作用: 在数组内寻找指定数据(倒叙寻找)

              返回值:

                  1. 找到数据的时候, 返回数据第一次出现的下标

                  2. 找不到的时候, 返回 -1

5.数组的塌陷

        数组塌陷：在对数组进行操作的时候，会使数组的长度产生变化，同时，操作的数组那个项的下一个索引会被跳过，

        从而造成数组的某项会被跳过，这种叫做数组塌陷现象。