Js(二）数组的相关操作

推荐阅读： JS数组奇巧淫技

1. 数组对象

数组也是对象，也可以通过构造函数生成。（有关对象的知识将在后面介绍，这里知道有这种写法即可）。

1.1 数组的两种写法

1. 字面量方法

    // 字面量方法
    var arr = [];
    var arr = [1,2,3];

2. 构造函数

• var 变量名称 = new Array()：创建一个空数组
• var 变量名称 = new Array(size)：创建一个指定大小的数组
• var 变量名称 = new Array(data1,data2,…)：创建一个带数据的数组

    // 空数组
    var arr1 = new Array();
    // 添加数据，可以传参数
    var arr2 = new Array(1,2,3);
    var arr3 = new Array("zs","ls","ww");
    var arr4 = new Array(3); //创建一个长度为3的数组
    console.log(arr1);
    console.log(arr2);
    console.log(arr3);
    console.log(arr4);

    // 检测数组的数据类型：object
    console.log(typeof(arr));
    console.log(typeof(arr3));

	
    // instanceof检测某个实例对象是否属于某个对象类型
    console.log(arr instanceof Array); // true
    console.log(arr2 instanceof Array); // true

2. 数组常用方法

2.1 增

2.1.1在数组的最后添加数据

可以使用push()方法在数组的最后新增一条数据，并且将新增内容之后，数组当前的长度返回。
push()方法可以接收一个或多个参数,添加多个数据。

var arr = ['a','b','c'];
var res = arr.push('d');
console.log(res); // 4
console.log(arr);// [a,b,c,d]
var res1 = arr.push('e','f');
console.log(arr);// [a,b,c,d,e,f]

2.1.2 在数组的首部添加数据

可以使用unshift()方法在数组的首部添加一条数据，并且将新增内容之后数组当前的长度返回。
unshift()方法可以接收一个或多个参数,添加多个数据。

var arr = ['a','b','c'];
var res = arr.unshift('d');
console.log(arr); //[d,a,b,c]
var res1 = arr.unshift('e','f');
console.log(arr); // Array(6) [ "e", "f", "d", "a", "b", "c" ]

2.2 删

2.2.1 在数组的最后删除一条数据

数组的pop()方法可以删除数组中的最后一条数据，并且将删除的数据返回。

    var arr = [1,2,3,4]
    // 尾删，删除最后一项数据,并返回删除掉的数据
    // 不需要传参
    console.log(arr.pop()); // 4
    console.log(arr); // Array(3) [ 1, 2, 3 ]

2.2.2 在数组的前面删除一条数据

数组的shift()方法可以删除数组中的第一条数据，并且将删除的数据返回。

    var arr = [1,2,3,4];
    // 首删，删除第一项数据，不需要传参，返回删除掉的数据
    console.log(arr.shift());// 1
    console.log(arr); // Array(3) [ 2, 3, 4 ]

案例：将数组中的第一项移动到最后一项

• 删除第一项
• 将删除的项添加到最后一项

arr.push(arr.shift());

2.3 splice()方法

splice()方法比较特殊，可以实现插入，删除和替换元素
splice方法可以传入多个参数：【splice(index，number, element1, element2,…) 】

• 第一个参数代表删除元素的开始位置
• 第二个参数代表删除元素的个数，可以为0
• 第三个元素开始就是要替换的新的数据

2.3.1 删除

要实现删除功能，就只需要传前两个参数，返回值是删除的元素组成的数组。

    var arr = [1,2,3,4,5,6,7,8,9,10];
    // 删除功能，传前两个参数，返回值是删除的元素组成的数组
    console.log(arr.splice(2,5)); // Array(5) [ 3, 4, 5, 6, 7 ]
    console.log(arr); // Array(5) [ 1, 2, 8, 9, 10 ]

2.3.2 替换

实现替换，需要传3个以上的参数

    var arr = [1,2,3,4,5,6,7,8,9,10];
    // 替换功能，传3个及以上的参数
    arr.splice(2,5,"haha","hello");
    console.log(arr); // Array(7) [ 1, 2, "haha", "hello", 8, 9, 10 ]

2.3.3 插入

实现插入功能，需要传3个及以上的参数，但是第二个参数必须为0。

    var arr = [1,2,3,4,5,6,7,8,9,10]	
    arr.splice(2,0,"hello");
    console.log(arr);

2.4 合并方法concat()

concat()方法可以将两个数组合并，返回值是合并后的数组，原数组不受影响。

    var arr = [1,2,3,4];
    var arr1 = arr.concat([5,6,7]);
    console.log(arr); // Array(4) [ 1, 2, 3, 4 ]
    console.log(arr1); // Array(7) [ 1, 2, 3, 4, 5, 6, 7 ]

2.5 截取方法slice()

slice(start,end)可以从数组中截取一部分，截取的内容包含start,但不包含end。截取后原数组不受影响。

    var arr = [1,2,3,4,5,6,7,8,9,10];
    // 参数为正
    var arr1 = arr.slice(3,7);
    console.log(arr1); // Array(4) [ 4, 5, 6, 7 ]
    // 参数为负，结束位置是-1
    var arr2 = arr.slice(-7,-1); 
    console.log(arr2); // Array(6) [ 4, 5, 6, 7, 8, 9 ]
    // 只书写一个参数，参数是截取的开始位置
    var arr3 = arr.slice(7); // Array(3) [ 8, 9, 10 ]
    console.log(arr3);
    console.log(arr); // 原数组不受影响

2.6 查找元素位置indexOf()

indexOf()用于查找元素在数组中的位置，如果找到了指定的元素，则返回元素对应的位置
如果没找到，则返回-1。

• indexOf查找的是某个元素在数组中从前往后第一次出现位置的下标
• lastIndexOf查找的是某个元素从前往后最后一次出现位置的下标，也就是从后往前第一次出现位置的下标
• 可以指定第二个参数，作为开始查找的位置

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

    // 查找某个元素在数组中从前往后第一次 出现位置的下标
    console.log(arr.indexOf(4)); // 3
    // 查找某个元素在数组中从前往后最后一次出现位置的下标
    console.log(arr.lastIndexOf(4)); // 10
    // 如果没找到返回-1
    console.log(arr.lastIndexOf(11)); // -1

2.7 倒序reverse()方法

reverse()方法会将数组中的内容反转，并且会修改原来的数组

    // 倒序排列,reverse()返回值就是倒序数组
    var arr = [1,2,3,4]
    console.log(arr.reverse()); //Array(4) [ 4, 3, 2, 1 ]
    console.log(arr); // Array(4) [ 4, 3, 2, 1 ]

2.8 sort()方法

sort()方法默认按照字符编码顺序从小到大排列

   // 排序，默认按照字符编码顺序从小到大排列
    var arr = [1,2,3,4,5,6,7,8,9,10,20,30];
    arr.sort();
    console.log(arr); // 1,10,2,20,3,30,4,5,6,7,8,9

sort()函数也可以添加一个一个比较函数的参数，进行大小的比较

var arr = [1,2,3,4,5,6,7,8,9,10,20,30];
arr.sort(function(a,b){
      if (a < b) {
        return -1;   //表示 a 要排在 b 前面
      } else if (a > b) {
        return 1;  //表示 a 要排在 b 后面
      } else {
        return 0;  //表示 a 和 b 保持原样，不换位置
      }
    });
    console.log(arr); //Array(12) [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, … ]

2.9 toString()方法

toString()方法可以将数组转字符串。

	var arr= [1,2,3,4];   			
	var str = arr.toString();
        console.log(str); // 1,2,3,4
        console.log(typeof str); //string

2.10 join()方法

join(）方法将数组连接成字符串，默认以逗号连接，也就是调用toStirng()，如果传递了参数，就会将传递的参数作为元素和元素的连接符号。

    var arr = [1,2,3,4,5,6,7,8,9,10,20,30];

    // 转字符串方法,连接成字符串，默认以逗号连接
    var str = arr.join();// 1,2,3,4,5,6,7,8,9,10,20,30
    console.log(str);
    var str = arr.join("+");
    console.log(str); // 1+2+3+4+5+6+7+8+9+10+20+30

2.11 includes()方法

includes()方法可以判断数组中是否包含某个元素，有则返回true,没有则返回false

    var arr = [1,2,3,4];
    console.log(arr.includes(4)); //true
    console.log(arr.includes(12)); //false

2.12 清空数组

• 令arr = []
• 令数组的长度为0
• 使用splice()方法

    var arr = [1,2,3,4,5,6,7,8,9,10,20,30];
    // arr = [];
    // arr.length = 0;
    arr.splice(0,arr.length);
    console.log(arr);

3. 数组的排序

还有很多种排序，这里目前只列出最简单的，待补充。

3.1 桶排序

这里参考了《啊哈！算法》第一章，初学者如果不理解，可以参考这本书。

	// 10以内的排序
        let arr = [5,6,8,7,2];
        let wrapper = new Array(10);
        for(let i=0;i<arr.length;i++){
            let number = arr[i];
            wrapper[number] = 1;
        }
        for(let i = 0;i < wrapper.length;i++){
            if (wrapper[i] == 1){
                console.log(i);
            } 
        }
        //  2 5 6 7 8

	//  如果有重复数字，怎么办？ [2,5,7,4,5]
        // 数组的fill方法的作用: 设置数组中所有元素的值为指定的数据
        let arr = [2,5,7,4,5]
        let wrapper = new Array(10);
         // 初始化为0
        wrapper.fill(0);
        for(let i=0;i<arr.length;i++){
            let number = arr[i];
          	// 每出现一次，桶内的数据 + 1
            wrapper[number] += 1;
        }
        for(let i = 0;i < wrapper.length;i++){
            for(let j =0;j<wrapper[i];j++){
                console.log(i);
            } 
        }// 2 4 5 5 7

3.2 选择排序

我们小学是如何排序的，比如5,4,2,7,3是不是可以拿第一个和后面的逐个比较，如果后面的数比它小，交换位置，交换后和下一个比较，直到取出最小的那个数，然后是第二个和后面的逐个比较

        // 第0个依次和后面的比较，取出倒数第一小的值
        // 第一个依次和后面的比较，取出倒数第二小的值
        // 第二个依次和后面的比较
        let arr = [5,4,2,7,3];
        for(let i=0;i<arr.length;i++){
            for(let j =i+1;j<arr.length;j++){
                if(arr[j] < arr[i]){
                    let temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        console.log(arr);

3.3 冒泡排序

冒泡排序的每一轮选取最大的元素
冒泡排序是把数字和临近的数字比较，如果大于临近的数字，交换位置，这样每轮都能选取最大的元素

        // 第0个依次和后面的比较，取出倒数第一小的值
        // 第一个依次和后面的比较，取出倒数第二小的值
        // 第二个依次和后面的比较
        let arr = [5,4,2,7,3];
        // i 是循环的次数
        for(let i=0;i<arr.length-1;i++){
        	// j是每次的比较，每次都从最底部开始
            for(let j =0;j<arr.length -1 - i;j++){
                if(arr[j] > arr[j+1]){
                    let temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        console.log(arr);

4. 数组算法题

这些内容待补充

参考博客：力扣加加

• 两个数组的交集
• 数组中第K小的数
• 数组向右移k位
• 两数之和
• 旋转数组
• 买卖股票的最佳时机
• 三数之和
• 只出现一次的数字
• 加一
• 求数组每个元素的和
• 统计数组中每个元素出现的次数
• 求数组最小值和最大值
• 数组去重
• 数组中出现次数最多的元素
• 是否存在重复

5. 数组面试题