数组

• 什么是数组？

  • 数组 是一种数据类型, 他也是属于 引用数据类型(复杂数据类型)
  • 根据字面意思来说, 存放数字的一个组合, 但这样说有点片面了

• 更完善的说法: 数组是存放一些数据的集合

  • 换句话说: 我们把数据放在一个盒子中, 这个盒子就叫做数组, 注意! 数组内的数据是有顺序的,且可以是任何数据类型

创建数组

两种方法

• 1.字面量的方式

  • 语法: var arr = [1, 2, 3, 'q', 'w']

• 2. 内置构造函数的方式

  • 语法1: var arr = new Array() 创建一个空数组
  • 语法2: var arr = new Array(5) 创建一个有长度的数组,但是是空的
  • 语法3: var arr = new Array(1, 2, 3) 创建一个有内容的数组

// 1: 字面量方式创建数组
var arr = [1,2,3,'q','w','e',true]
console.log(arr)

//2: 内置构造函数创建数组

    //2.1 创建一个空数组
    var arr1 = new Array()
    console.log(arr1)
    
    // 2.2 创建一个有长度的数组
    var arr2 = new Array(5)
    console.log(arr2)
    
    // 2.3 创建一个有内容的数组
    var arr3 = new Array(1, 2, 3, 'q', 'w', 'e')
    console.log(arr3)

数组的 length 属性

• length 翻译过来就是 长度的意思

• 代表 这个数组内, 有多少个成员

  • 语法: 数组名.length

var arr = [1,2,3,'q','w','e',true]
console.log(arr.length)  //7

数组的索引

• 索引 也叫做 下标

  • 就是指一个数据, 在这个数组内排列在第几个 位置上
  • 注意: 在 JS 中, 索引(下标) 是从 0 开始计算的

• 如果想要获取到数组指定位置的值, 可以通过下标来获取

  • 语法: 数组名[下标] -> 能够获取到这个数组中对应下标的成员具体的值

    var arr = [r, 2, 3, w, q, c]
//对应的索引    0  1  2  3  4  5
    console.log(arr[3])  //w
    console.log(arr[5])  //c

遍历数组

• 想办法 拿到 数组的每一个成员

  • 想拿到数组的所有成员, 需要先想办法拿到数组的所有下标
  • 规律: 所有数组的下标都是从 0 开始的, 然后到 数组.length - 1 结束

//可以利用循环,拿到每个数值对应的下标,然后就拿到了对应的值
var arr = [1, 2, 3, 4, 5, 6]
for(var i = 0;i < arr.length;i++){
    console.log(arr[i])
}

数组案例1: 求数组中所有数字的和

var arr = [2,6,1,7,4]    //声明一个数组
var sum = 0    //声明一个存放和的变量,赋值为0
for(var i = 0;i < arr.length;i++){
    sum += arr[i]   //把数组里面的每个值找出来都加进和的变量里
}
console.log(sum)

数组案例2:求数组中的最大值

var arr = [2,6,1,77,52,25,7]  //声明一个数组
var max = arr[0]  //声明一个保存最大值的变量,然后把这个变量赋值为第一个元素
for(var i = 1;i < arr.length;i++){  //遍历数组,因为第一个元素已经有了,所以从第二个开始
    if(arr[i] > max){   //如果元素比变量里的值大的时候
        max = arr[i]  //把这个元素赋值给最大值的变量
    }
}
console.log(max)

数组案例3:数组数组中新增元素,新建一个数组,里面存放10个整数(1~10)

var arr = []
for(var i = 0;i < 10;i++){
    arr[i] = i + 1
}
console.log(arr)

数组-冒泡排序,把数组[5,4,3,2,1]变成[1,2,3,4,5]

// 冒泡排序的核心是:
// 对比数组前一项和后一项, 如果前一项的值较大, 那么就往后挪 (这个排序之后是按照从小到大的顺序)
// 这里用到双层for循环

// 外层循环的时候:
    //i = 0  第1次循环  确定了[4]的值
    //i = 1  第2次循环  确定了[3][4]的值
    //i = 2  第3次循环  确定了[2][3][4]的值
    //i = 3  第4次循环  确定了[1][2][3][4]的值
    //i = 4  第5次循环  确定了[0][1][2][3][4]的值
        //第5次循环没有必要,因为已经确定了其他的位置,所以外层循环可以 - 1
        
 // 里层循环的时候:
   // 如果j < arr.length,那么在执行内部判断的时候,最后一次是判断arr[4] > arr[5]  
   // 但是我们这里没有arr[5],所以这一步没有必要,由此是j < arr.length - 1
   
   // 第一轮做对比的时候,已经把最后一个值的位置定好了,然后经过第二轮对比后,第二轮的值也就定好了
   // 所以第一轮可以少对比一次,第二轮少对比两次,因为最后两个值都确定了,
   // 需要减的数刚好是每次循环的时候i 的数字,由此可以在进行优化
   
var arr = [5, 4, 3, 2, 1]
for(var i = 0;i < arr.length - 1;i++){
    for(var j = 0;j < arr.length - i - 1;j++){
        if(arr[j] > arr[j + 1]){
            var temp = arr[j]
            arr[j] = arr[j + 1]
            arr[j + 1] = temp
        }
     }
 }
 console.log(arr)

数组-选择排序

// 选择排序的核心是:
// 假设下标为0的是最小值,然后找到小的之后交换位置

var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
// 下标    0, 1, 2, 3, 4, 5, 6, 7, 8
for(var i = 1;i < arr.length;i++){
    var min = i  //这里假设最小值的下标为0
    
    // j = i + 1 是因为每次都会确定一个最小值,在最前面,然后再找下一个
    
    for(j = i + 1;j < arr.length;j++){
        if(arr[min] > arr[j]){  //这里如果分支执行,说明在数组里面找到了比假设的小的元素
            min = j  //那么赋值为真实最小值的下标
        }
    }
    // 此时交换 真实最小值 与 我们假设的最小值
    var temp = arr[min];
    arr[min] = arr[i];
    arr[i] = temp;
}
console.log(arr)