JS（五）（数组，冒泡排序，选择排序）

学习新思想
80 阅读5分钟
数组

1.数组： 存放一些数据的集合，也是引用数据类型（复杂数据类型） 数组/对象/函数 2. 数组和对象将来如何选择？ 1. 示例： - 商品的详情存放到某一个对象中, 比如: 商品名, 商品价格, 商品折扣, 商品描述.... - 商品列表假设有 100个商品, 那么你就有100个商品详情, 按照上述的封装那么你有100个对象 - 我们可以将 这 100个 对象, 存放到某一个数组中, 进行维护管理

创建数组

  1. 字面量的方式创建
  2. 内置构造函数的方式创建
  • 数组内部是存放一些数据的，数据的类型没有限制
  • 但是在开发的时候一般需要将一个数组内数据类型限制为一个 比如： 纯字符串数组，纯数字数组，纯对象数组

1.字面量的方式创建（使用场景最多的方式）

    // var arr1=[]
   //console.log(arr1)
   var arr1=[true,undefined,null,999,578,'QF999']
   console.log(arr1)
  1. 内置构造函数的方式创建
  var arr2 =new Array()
  console.log(arr3)

2.1 创建一个有长度的数组

var arr3= new Array(5)
console.log(arr3)

2.2 创建一个有内容的数组

  var arr4 = new Array(500, 100, 200, 300, 'QF001',  'QF666')
        console.log(arr4)

数组的长度

数组的长度并固定, 取决于数组内部有多少个元素

  • 查看方式：
  • 打印数据，在控制台展开数组，找到最后的length
  • 打印 数组名.length
  • 当数组的长度===0 代表当前数组为空数组
  var arr=[1,2,3,4,5]
  console.log(arr)
  console.log(arr.length)

数组的索引（下标）

  1. 有什么用？
  • 表明数组的这个位置有什么内容
  • 下标是固定的，永远是 0 1 2 3 4 5...
  • 但是下标对应的内容，不是固定的
   var arr =[1,2,3,4,5]
   //下标：   0 1 2 3 4
   
   console.log('原数组：',arr)
   // console.log(arr[0]) // 会得到当前数组下标0这个位置上的值        1
  // console.log(arr[3]) // 会得到当前数组下标0这个位置上的值        4

  // 通过数组的下标, 我们也可以修改数组中某一个元素的内容
        arr[2] = '新的数据'

        console.log('修改后的数组: ', arr)

        
        // var arr1 = [100, 200, 'QF004', true]
        // var arr2 = [5, 4, 3, 2, 1]
        // console.log(arr1)
        // console.log(arr2)

数据遍历

需求：拿到数组各个位置上的值

 var arr=[1, 2, 3 ,4, 5, 6, 7, 8, 9, 10, 1, 2]
 //下标   0  1   2  3  4  5 6   7  8  9   10 11
 
 //console.log(arr[0])
 //console.log(arr[1])
 //console.log(arr[2])
 
 
 //for (var i=0;i<=arr.length-1;){
 for (var i=0;i<arr.length;i++){
 //console.log(i)
 console.log(arr[i])
 }

JS案例

    1. 找出数组中的最大值
      var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
      var max = arr[0]
      console.log(arr)
      for (var i = 0; i < arr.length; i++) {
       if (arr[i] > max) {
           max = arr[i]
       }

       } console.log(max)
       
       2.找出数组中所有内容相加的和
         var arr = [1, 2, 3, 4, 5]
         console.log[arr]
         var sum = 0
         for (var i = arr.length - 1; i >= 0; i--) {
          sum = sum + arr[i]
        } console.log(sum)
    3.封装一个函数，名为includes
        功能为传入一个数组和数字，判断这个数组中是否包含这个数字
       包含返回true，否则返回false
        function includes(a, b) {
        for (var i = 0; i < arr.length; i++) {
        if (b === arr[i]) {
          return true
           }
         }
            return false
         }
        var arr = [1, 2, 3, 4, 5]
       console.log(includes(arr, 6))
       
      4. 封装一个函数，名为 indexof功能为 传入一个数组和数字，判断这个数组中是否包含这个数字包含返回 这个数字的下标(从左到右第一个)否则返回-1
      function indexof(a, b) {
       for (var i = 0; i < arr.length; i++) {
       if (b === arr[i]) {
           return i
           }
          } return -1
         }
       var arr = [1, 2, 3, 4,]
         console.log(indexof(arr, 4))
         
         5.封装一个函数，名为 lastIndexof功能为 传入一个数组和数字，判断这个数组中是否包含这个数字包含返回 这个数字的下标(从右到左第一个)否则返回-1
           function lastIndexof(a, b) {
            for (var i = arr.length - 1; i >= 0; i--) {
                if (b === arr[i]) {
                    return i
                }
            } return -1
        }
        var arr = [1, 2, 3, 4, 2, 2, 2]
        console.log(lastIndexof(arr, 2))

冒泡排序

算法/设计模式 这两个不是一个东西, 但是都是为了解决某一类问题的最佳解法

//冒泡排序（基础班，没有优化）
for(var j=0;j<arr.length;j++){
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
                }
            }
console.log('第 ', j + 1, ' 轮冒泡排序后: ', arr)


 // 1. 数组的前后两项交换 ([0] 和 [1])
        // var temp = arr[0]   // [0] 拥有了备份
        // arr[0] = arr[1] // 将 [1] 的值 放在了 [0] 的位置上
        // arr[1] = temp   // 将 原本 [0] 的值, 放在了 [1] 的位置上
        // console.log(arr)
        
        
           /**
         *  因为要做前后两项的对比, 所以我们需要先拿到数组的所有元素, 所以写了一个 for 循环
         *
         *      在 循环内部 判断, 如果 前一项比后一项的值要大, 那么将前后两项交换位置
        */
        // 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   // 将原本 前一项(当前项) 的值, 放在 后一项 的位置上
        //     }
        // }
        // console.log('第 1 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 2 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 3 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 4 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 5 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 6 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 7 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 8 轮冒泡排序后: ', arr)

        // 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
        //     }
        // }
        // console.log('第 9 轮冒泡排序后: ', arr)

冒泡排序优化

  优化3，去掉多余的无用对比
  for (var j = 0; j < arr.length - 1; j++) {
        //     console.log('当前是第 ', j + 1, ' 次循环, 此时变量 j ===', j)
  for (var i = 0; i < arr.length - 1 - j; 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)
      
       // for (var j = 0; j < arr.length - 1; j++) {
        //     for (var i = 0; i < arr.length - 1; i++) {
        //         /**
        //          *  当前 数组 arr.length === 9
        //          * 
        //          *  那也就是说 i 最大 为 8
        //          * 
        //          *  所以最后一轮循环 i === 8
        //          * 
        //          *  判断的内容为 arr[i] > arr[i + 1]
        //          *              arr[8] > arr[9]
        //          * 
        //          *  所以最后一次 判断没有意义, 所以我们此时应该让 内层循环 - 1
        //         */
        //         if (arr[i] > arr[i + 1]) {
        //             var temp = arr[i]
        //             arr[i] = arr[i + 1]
        //             arr[i + 1] = temp
        //         }
        //     }
        // }
        // console.log('冒泡排序后: ', arr)
        
         优化 1: 外层循环可以减少一次
       
         *      一共 9 个数字, 所以需要执行 9 次 冒泡
         * 
         *      但是前 8 次执行完毕后, 就剩下一个位置和一个数字 没有验证了
         * 
         *      所以没必要执行最后一次了, 因为没有多的位置
        */
        for (var j = 0; j < arr.length - 1; j++) {
         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
                }
            }
         }
         console.log('冒泡排序后: ', arr)

选择排序

 var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
 //         0  1  2  3  4  5  6  7  8
 
               第几次循环      假设谁是最小值      和谁交换        内层循环从 ? 开始
  
    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++) {
            // 1. 假设 k 是最小值的下标, 保存在 minIndex
        var minIndex = k
            // 2. 循环会帮我们找到真实最小值的下标, 并保存在变量 minIndex
        for (var i = k + 1; i < arr.length; i++) {
          if (arr[minIndex] > arr[i]) {
                    minIndex = i
                }
            }
            // 3. 交换 真实最小值(下标 minIndex) 和 假设最小值 (k) 的位置
         var temp = arr[k]
         arr[k] = arr[minIndex]
         arr[minIndex] = temp
        }

        console.log('排序后: ', arr)
avatar
文章
阅读
粉丝