day05 JS数组-笔记

天生岁月
129 阅读3分钟

JS数组

数组介绍

1.JS数组的概念
    数组的字面意思就是一组数据，一组数据（一般情况下是相同类型的数据, 不一定都是数字）
    js的数组的成员可以是任意类型,它是可以动态扩容
2.数组的作用
    使用单独的变量名来存储一系列的值, 数组是特殊的变量，它可以同时保存一个以上的值。
如上节课中我们学过的arguments就是一个(伪)数组, 里面保存了多个参数.
3.为什么要使用数组? 
    如果您有一个项目列表（例如汽车品牌列表），在单个变量中存储这些品牌名称是这样的:  
var cars1=“Volvo”, cars2 =“BMW”, cars3 = ”Benz“;
    不过，假如您希望对变量进行遍历并找出特定的那个值？或者如果您需要存储 300个汽车品牌，而不是
    3个呢？  解决方法就是创建数组！

数组的定义和使用

1, 数组的定义

方式一:  
      new Array（参数，参数,...）: 只有一个数字参数时是数组的长度（new可以省略,但一般尽量写上）
例如: 
     var arr = new Array();   //定义一个空数组 
     var arr = new Array(10);  //创建一个包含 10 个元素的数组，没有赋值
     var arr = new Array(“芙蓉姐姐”,30);  //创建一个数组有两个元素
方式二: 
     var arr = [1,2,3,4,5];  //字面量定义方式

2, 数组元素的获取(访问)

通过下标(索引)获取
    arr[0]: 表示数组的第一个元素，0是下标，也叫索引，下标从0开始
    arr[1]: 表示数组的第二个元素，1是下标

3, 数组的长度

数组长度(数组元素的个数) : arr.length
length属性, 不仅是只读的，也可以设置
例如: 
var colors = new Array("red", "blue", "green");
colors.length=2;
console.log(colors[2]);
数组的下标从0开始, 所以数组的最后一个元素的下标为： arr.length – 1
注意: 下标可以是变量或表达式

4， 数组的赋值

给数组赋值，就是给数组的元素赋值，需要通过给数组的每个元素一一赋值，
如：arr[0] = 20;  //让数组的第一个元素的值为20；
    arr[1] = 12;  //让数组的第二个元素的值为12；

以下为通过for循环给数组的每个元素赋值，赋成下标的平方。
    for(var i=0;i<10;i++){
         arr[i] = i*i;
    }

以下为通过for循环给数组的每个元素赋值，赋值一个随机数:Math.random()
    for(var i=0;i<10;i++){
         arr[i] = Math.random();
    }
Math.random()的范围是: 0~1(包括0, 不包括1)

5, 数组的使用

使用数组就是在使用数组的每个元素，因为数组相当于若干个相同类型的变量。
遍历数组: 
  之前我们讲过通过下标获取单个数组元素, 但有时候我们需要批量使用数组, 这个时候我们需要遍历整个数组.
   1, 普通for循环
    for(var i=0; i<5; i++){
         console.log(arr[i]);
    }
   2, for...in遍历:  用于遍历数组或者对象
    for(var i in arr){
         console.log(arr[i]);
    }

  for和forin的区别?
  for是根据数组的length长度,来决定遍历的次数
  forin 是根据内容来遍历次数
  forin还能遍历不是数值的下标,for只能遍历下标为数值的
  数组是特殊的对象

数组中的常用函数

  1. pop() 删除数组的最后一位,返回被删除的元素,它会改变原来的数组
  var arr = [11, 22, 33, 44];
  var res = arr.pop();
  console.log(arr);
  console.log(res);

  2.push() 往数组的最后位置添加元素(1或多个),返回数组的新长度
  var arr = [11, 22, 33, 44];
  var res = arr.push("王响", "游超");
  console.log(res);
  console.log(arr);

  3.shift() 删除数组的第一位成员,返回被删除的成员
  var arr = [11, 22, 33, 44];
  console.log(arr.shift());
  console.log(arr);

  4.unshift() 往数组的第1个位置,添加1个或多个成员,返回数组的新长度
  var arr = [11, 22, 33, 44];
  console.log(arr.unshift("AA", "BB"));
  console.log(arr);

  5.sort 排序,它默认是根据ASCII码,进行比较
   0-9  48-57
   a-z  97-122
   A-Z  65-90
  var arr = [2, 9, 7, 11, 4, 6, 8,];
  arr.sort(function (a, b) {
    // return a - b; 升序
    return b - a;   //降序
  })
  console.log(arr);

  6.reverse() 倒序
  var arr = ["AA", "BB", "CC", "DD"];
  arr.reverse()
  console.log(arr);

  7.slice() 它包含开始位置,不包含结束位置
  //下标     0   1   2   3   4
  var arr = [11, 22, 33, 44, 55]; //33-44
  var res = arr.slice(2, 4);
  console.log(res);
  console.log(arr);
  
  8.splice() 
  // ()内2个参数,删除  返回被删除的元素,并且是一个新数组
  var arr = [11, 22, 33, 44, 55, 66];
  console.log(arr.splice(3, 1));
  console.log(arr);
  
  // 3个参数, 第2个参数是0,插入,1或1以上,替换
  var arr = [11, 22, 33, 44, 55, 66];
  arr.splice(3, 0, "aaa", "bbb");
  console.log(arr);

  // 1或1以上,替换
  var arr = [11, 22, 33, 44, 55, 66];
  arr.splice(3, 2, "ccc");
  console.log(arr);

  9.concat();合并 会返回一个新的数组
  var arr1 = [11, 22, 33];
  var arr2 = ['AA', "BB", 'CC'];
  var arr3 = arr1.concat(arr2, "ccc", 99)
  console.log(arr3);

  10.join() 默认是 用 ","隔开,返回字符串
  var arr = [2022, 12, 12];
  console.log(arr.join(""));//20221212
  console.log(arr.join("-"));// 2022-12-12
  console.log(arr.join("/"));// 2022/12/12

  //总结:会改变原来数组的方法有哪些?
  //会改变:pop,push,shift,unshift,sort,reverse,splice
  //不改变:slice,concat,join()

  //实现数组的拷贝(浅)
  var arr = [11, 22, 33];
  //方式1 concat()
  var arr1 = arr.concat();
  console.log(arr1);
  console.log(arr);

  //方式2 slice()
  var arr = [11, 22, 33];
  var arr1 = arr.slice(0)
  console.log(arr1);

冒泡排序

思路：输入6个无序的数字，从头到尾依次比较相邻两个数字大小，若大数在前、小数在后，则交换两数位置
，依次比较，使全部数据按从小到大排列

例如:  将数组[8,9,7,6,5,4]进行升序排序[4,5,6,7,8,9]

image.png

image.png

image.png

代码实现

var arr = [4,5,6,7,8,9]
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] < arr[j + 1]) {
               var temp = arr[j + 1]
               arr[j + 1] = arr[j]
               arr[j] = temp
            }
        }
    }
    console.log(arr);

选择排序

思路: 从小到大,每一趟找出一个最小值
循环的过程中找到比较小的值时,记录下下标,等比完之后再换位置
比较多少趟？arr.length
每一趟要比较多少次,每一次都要比到数组的最后一个元素

数组的长度: arr.length      6
比较的趟数: arr.length-1    比较5趟  索引表示 0 ~ arr.length-2
比较的趟数:        比较的次数   每一趟都找出了一个最小值
        第一趟: 0         5   (0,1)          
        第二趟: 1         4   (1,2)        
        第三趟: 2         3   (2,3)
        第四趟: 3         2   (3,4)
        第五趟: 4         1   (4,5)


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

//外层控制比较的趟数 需要比较5趟
for(var i = 0; i < arr.length-1; i++){
var min = i //假设每一趟的第一个是最小值
    for(var j = i+1; j < arr.length; j++){
    //判断索引为min的元素 跟 后面的元素的大小
        if(arr[min] > arr[j]){
            //条件成立,则说明min所以记录的不是最小值,j才是最小值
            min = j
        }
    }

    if(min != i){
        //min不等于i 说明最小值是其他的元素,则需要换位置
        var temp = arr[min]
        arr[min] = arr[i]
        arr[i] = temp
    }
}
console.log(arr)

快速排序

1.定义个方法,输入一个数组
2.如果数组的长度小于2,就返回输入的数组 (小于2个,没办法比较)
3.如果是大于等于2,找出下标,遇到不能被整除,向下取整//[4,8,3]  //3/2=1.5  取整-->1
4.通过中间下标,得到中间数,并且要从原来数组扣出来
5.准备2个空数组,左边和右边的空数组
6.大于中间数 放置 右边数组,否则放置左边数组
7. 递归进行继续拆,拆到只有1个数的数组,就不拆
   进行合并  左边数组+中间+右边数组
  var a = [5, 6, 7, 4, 3]
  //1.定义个方法,输入一个数组
  function quickSort(arr) {
    //2.如果数组的长度小于2,就返回输入的数组 (小于2个,没办法比较)
    if (arr.length < 2) {//临界点
      return arr; //返回数组
    }
    //3.如果是大于等于2,找出下标,遇到不能被整除,向下取整
    var middleIndex = parseInt(arr.length / 2);
    //4.通过中间下标,得到中间数,并且要从原来数组'扣'出来
    var middleVal = arr.splice(middleIndex, 1)
    //5.准备2个空数组,左边和右边的空数组
    var left = [], right = [];
    //6.大于中间数 放置 右边数组,否则放置左边数组
    for (var i = 0; i < arr.length; i++) {
      if (arr[i] > middleVal) {
        right.push(arr[i])
      } else {
        left.push(arr[i]);
      }
    }
    //7. 递归进行继续拆,拆到只有1个数的数组,就不拆
    //   进行合并  左边数组+中间+右边数组
    return quickSort(left).concat(middleVal, quickSort(right))
  }
  console.log(quickSort(a));
avatar
文章
阅读
粉丝