leetcode刷题知识点总结（刷题必备）

1.字符串比较之localeCompare

js提供了字符串的对比方法localeCompare()，该方法返回的是一个数字用来表示一个参考字符串和对比字符串是排序在前，在后或者相同。(考虑了默认的本地排序规则)
stringObject.localeCompare(target)

• target 要以本地特定的顺序与 stringObject 进行比较的字符串。
• 返回值
  说明比较结果的数字。
  如果 stringObject 小于 target，则 localeCompare() 返回小于 0 的数。
  如果 stringObject 大于 target，则该方法返回大于 0 的数。
  如果两个字符串相等，或根据本地排序规则没有区别，该方法返回 0。

console.log("aa".localeCompare("ca"));//-1 'aa'<'ca'
console.log("ca".localeCompare("ca"));//0  'aa'='ca'
console.log("ca".localeCompare("aa"));//1  'aa'>'ca'

该方法基本不单独使用，大部分时间是配合字符串排序使用的。

var strList = ['cc', 'ee', 'ca', 'aa'];
strList.sort((a, b) => {
    return a.localeCompare(b);//升序
});
console.log(strList);//['aa', 'ca', 'cc', 'ee']

//a.localCompare(b) – 升序
//b.localCompare(a) – 降序

2.ES6之数组的flat(Infinity)扁平化，实现多维数组转成一维数组

let arr = [1, 2, ,[[3, 4],[5, 6]]]
//使用 Infinity 作为深度，展开任意深度的嵌套数组
//flat() 方法会移除数组中的空项
console.log(arr.flat(Infinity)); // [ 1, 2, 3, 4, 5, 6 ]
console.log(arr.flat()); // [ 1, 2, [3,4],[5,6] ]
console.log(arr.flat(1)); // [ 1, 2, [3,4],[5,6] ]
console.log(arr.flat(2)); // [ 1, 2, 3, 4, 5, 6 ]

1351. 统计有序矩阵中的负数（javascript）Count Negative Numbers in a Sorted Matrix

566. 重塑矩阵(javascript)566. Reshape the Matrix

1260. 二维网格迁移(javascript)Shift 2D Grid

3.find()，findIndex()，indexOf()，lastindexOf

1346. 检查整数及其两倍数是否存在(javascript)1346. Check If N and Its Double Exist

1.find()与findIndex()参数与用法相同
不同

• find根据条件返回元素，findIndex返回索引；
• 找不到时find返回undefined，findIndex返回-1。

2.findIndex()与indexOf()

• findIndex比indexOf更强大一些，可以通过回调函数查找对象数组
• indexOf只能查找数组中指定的值，不过indexOf可以指定开始查找位置的索引

3.1 find()

find()方法返回数组中第一个满足条件的元素,找不到返回undefined 该方法ES6新增。

语法： arr.find(callback)
callback函数有三个参数。

• item：每一次迭代查找的数组元素。
• index：每一次迭代查找的数组元素索引。
• arr：被查找的数组。

var testArr1 = [20, 12, 362, 26, 965, 22, 26, 35];
var findItem1 = testArr1.find( (item, index, arr)=> {
    console.log(item, index, arr);
    return item > 361
});
console.log("findItem1",findItem1);

//  0 (8) [20, 12, 362, 26, 965, 22, 26, 35]
//  12 1 (8) [20, 12, 362, 26, 965, 22, 26, 35]
//  362 2 (8) [20, 12, 362, 26, 965, 22, 26, 35]
//  findItem1 362

//也可以在对象数组中根据对象属性作为判断条件查找
var testArr2 = [{
    name: 'aaa',
    id: '111'
}, {
    name: 'bbb',
    id: '222'
}, {
    name: 'ccc',
    id: '333'
}]
var findItem2 = testArr2.find( (item, index, arr)=>{
    return item.name == 'ccc'
})
console.log(findItem2) //{name:'ccc',id:'333'}

3.2 findIndex

findIndex:找出第一个符合条件的数组成员的索引号 没找到会返回-1，该方法ES6新增。

语法： arr.findIndex(callback)
callback函数有三个参数。

• item：每一次迭代查找的数组元素。
• index：每一次迭代查找的数组元素索引。
• arr：被查找的数组。

const arr = [{
        id: 1,
        name: '徐毅叶'
    },
    {
        id: 2,
        name: '黑叶猴'
    },
    {
        id: 3,
        name: '黑叶猴22'
    }
]
const result1 = arr.findIndex(item => {
    return item.id == 3
})
const result2 = arr.findIndex((item,index,arr) => {
    return index > 0
})
const result3 = arr.findIndex(item => {
    return item.id > 3
})
console.log(result1); // 2
console.log(result2); // 1
console.log(result3); // -1

var num = this.tableDataChange.findIndex((n) => n.state == "1");
//num == -1

3.3 indexOf 和 lastIndexOf的区别

indexOf() 和 lastIndexOf() 都是索引文件

• indexOf() 是查某个指定的字符串在字符串首次出现的位置（索引值）（从左往右遍历），找不到就返回-1
• lastIndexOf() 是查某个指定的字符串在字符串最后一次出现的位置（索引值）（从左往右遍历），找不到就返回-1
• 这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1。在比较第一个参数与数组中的每一项时，会使用全等操作符；也就是说，要求查找的项必须严格相等（就像使用===一样）。

相同点

//string.indexOf(searchvalue,start)
//searchvalue-查找的值
//start-开始的位置，可选，理论上是从0到string.length-1,如省略该参数，则将从字符串的最后一个字符处开始检索。

//string.lastIndexOf(searchvalue,start)
//searchvalue-查找的值
//start-开始的位置，可选，理论上是从0到string.length-1,如省略该参数，则将从字符串的最后一个字符处开始检索。

查找数组

let arr = [1, 2, 1, 8, 0, 1, 2, 3, 0, 1, 2]
console.log(arr.indexOf(0));//4
console.log(arr.lastIndexOf(0));//8

console.log(arr.indexOf(10)); //-1
console.log(arr.lastIndexOf(10)); //-1

查找字符串

let str1 = "abcdefghijklmnopqrstuvwxza"
console.log(str1.indexOf('a')); //0
console.log(str1.lastIndexOf('a')); //25
console.log(str1.indexOf('y')); //-1
console.log(str1.lastIndexOf('y')); //-1

4.filter

原理

filter()方法会创建一个新数组，原数组的每个元素传入回调函数中，回调函数中有return返回值，若返回值为true，这个元素保存到新数组中；若返回值为false，则该元素不保存到新数组中；原数组不发生改变。

let values=[NaN, 10, 10, 0, 10, 10, 10, 10, 10, 10] 
//过滤掉NaN和0
//1.
let Liet= values.filter((item) => {
   return !isNaN(item)&&item
 });
 //2.
let Liet= values.filter((item) =>!isNaN(item)&&item);
//[10, 10, 10, 10, 10, 10, 10, 10]

//
let Liet= values.filter((item,index,arr) => {
        console.log('values',item,index,arr);
        return !isNaN(item)&&item
 });

//获取两个数组之间的交集
let result = maxList.filter((item) => {
    return minList.indexOf(item) > -1
})

5.map

566. 重塑矩阵(javascript)566. Reshape the Matrix

557. 反转字符串中的单词 III(javascript)557. Reverse Words in a String III

塑造一个r行c列，全是0的多维数组

const ans = new Array(r).fill(0).map(() => new Array(c).fill(0));

map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

map() 方法按照原始数组元素顺序依次处理元素。
返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

注意： map() 不会对空数组进行检测。

注意： map() 不会改变原始数组。

let ids = this.dynamicTags.map((item) => item.id);
// ["1354306079344857089", "1368812632591613954", "1370252422465757185", "1425622827346993153"]

let numbers = [1, 4, 9];
let roots = numbers.map(Math.sqrt);
//numbers [1, 4, 9]
//roots  [1, 2, 3]
//Math.sqrt(4)---2求平方根

let numbers = [1, 4, 16];
let numbers1 = numbers.map((currentValue, index, array) => {
      console.log("numbers1", currentValue, index, array);
})
//currentValue 数组中正在处理的当前元素
//index 数组中正在处理的当前元素的索引。
//array   map 方法被调用的数组。   [1, 4, 16]
//1   0   [1, 4, 16]
//4   1    [1, 4, 16]
//16  2    [1, 4, 16]

function pow(x) {
    return x * x;
}
var arr = [1, 2, 3];
var results = arr.map(pow); // [1, 4, 9]
console.log(results);

我们不但可以计算简单的上述操作，还可以计算任意复杂的函数，例如，我们可以快速的将一个数字数组转化为字符串数组：

将数组的元素进行类型转换

var arr = [1, 2, 3];
var results = arr.map(String); 
console.log("results",results);// ['1', '2', '3']
console.log(results.map(Number))// [1, 2, 3]

有时候在使用map的时候也会出现误区，例如，把一个字符串数字转化为数字，可能会出现意想不到的结果，大家想想下面这个的值为什么呢?

var a=['1', '2', '3'].map(parseInt);//[1,NaN,NaN]，
说明： map会给callback传输三个参数，第一个参数是元素本身（当前元素），第二个参数是元素的索引值（当前元素的索引），第三个是原数组（map 方法被调用的数组），而parseInt可以接受一个参数，也可以接受两个参数，接受一个参数的时候该参数直接为需要转化的字符串；接受两个参数的时候：第一个参数是要转为数字的字符串，第二参数是要转化的进制。

在js中参数的个数不需要严格一致，所以这样下来map的前两个参数都自动传给了parseInt，就会导致parseInt接受了不存在的进制(第二个参数一般为2，8，10，16)而显示NaN。所以需要正常显示就需要让parseInt接受一个值或者将其第二个值默认为10

 var a=['1', '2', '3'].map(function(x){return parseInt(x);});
 // [1, 2, 3]

this.getCheckedNodesList=[
        {name:"张三",id:"1"},
        {name:"李四",id:"2"},
        {name:"赵武",id:"3"},
      ],

  computed: {
    treeDataList1() {
       this.getCheckedNodesList.filter((item)=>{
        return item.flag==1
      })
      let data=this.getCheckedNodesList.map((item)=>{
        return {
          remark:null,
          userId:item.id,
          userName:item.name,
        } 
      })
      return data
    }
  },

//直接使用  this.treeDataList1

6.reduce

Array的reduce()把一个函数作用在这个Array的[x1, x2, x3…]上，这个函数必须接收两个参数，reduce()把结果继续和序列的下一个元素做累积计算，

累加和

var arr = [1, 3, 5,3];
let results = arr.reduce(function (x, y) {
    return x + y;
}); // 12
console.log('results', results);

求积

var arr = [1, 3, 5,3];
let results = arr.reduce(function (x, y) {
    return x * y;
}); // 45
console.log('results', results);

要把[1, 3, 5, 7, 9]变换成整数13579，reduce()也能派上用场：

var arr = [1, 3, 5, 7, 9];
let results =  arr.reduce(function (x, y) {
    console.log(x,y);//x为结果，每次用结果和序列的下一个元素做计算
    // 1 3
    // 13 5
    // 135 7
    // 1357 9
    return x * 10 +y
});
console.log('results', results);//最后返回值13579

const sum = (arr) =>  {
  return arr.reduce(function(acr, cur){
    return acr + cur;
  });
}

7.深度优先和广度优先

js中的广度优先遍历（BFS）和深度优先遍历（DFS）

733. 图像渲染(javascript)733. Flood Fill

1、深度优先算法

深度优先搜索算法(Depth-First-Search):是一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。

//主要步骤：
//1．构建一个递归函数，函数参数应该最起码包括题目需求使用的参数（变化的）
//2．找到边界，递归函数里首先列出递归结束的条件，即满足要求或者超出范围
//3．接着列出所有可能移动或者变化的路径,还有进行的操作
var dfs= function (step,...) {
    if()  // 判断边界（不符合条件，跳过，不进行操作）
      {   
         return 
       }
    // 枚举每一种可能(满足条件)
    //进行的操作
   dfs(step+1,...);
   dfs(step-2,...);
}

深度优先遍历和广度优先遍历

深度优先就是自上而下的遍历搜索 广度优先则是逐层遍历

二者的区别
对于算法来讲 无非就是时间换空间 空间换时间ui

• 深度优先不须要记住全部的节点, 因此占用空间小, 而广度优先须要先记录全部的节点占用空间大
• 深度优先有回溯的操做(没有路走了须要回头)因此相对而言时间会长一点
• 深度优先采用的是堆栈的形式, 即先进后出
• 广度优先则采用的是队列的形式, 即先进先出

8.截取

8.1 截取字符串

8.1.1 slice()

返回一个索引和另一个索引之间的字符串(不改变原字符串),slice(start,end)有两个参数(start必需,end选填),都是索引,返回值不包括end
[start,end)

• start：必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
• end：可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

var str = "abcdefg"
console.log(str.slice(1, 5))//bcde,取1到5（不包含5）
console.log(str.slice(1))//bcdefg，取1到最后
console.log(str.slice(-9, 5))//abcde，开始位置倒数第9个元素，不存在，位置从0开始，从0到5（不包含5）
console.log(str.slice(-2, -9))//""，开始位置倒数第2个元素，即第五个5；取到倒数第9个不存在，返回空字符串

8.1.2 substr()

返回从开始位置到指定字符数的长度 substr(start,length)(不改变原字符串),start为索引,length为从开始索引计算的字符长度(start必需,length选填)

• start：必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。
  也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。

• length：可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 开始位置到结尾的字串。

var str = "abcdefg";
console.log(str.substr(2)) //  cdefg,截取-从下标2到最后
console.log(str.substr(2, 3)) // cde,截取-从下标2开始，3个字符
console.log(str.substr(-1)) // g ,截取-从下标倒数第1个(此处是正数第6个)到最后
console.log(str.substr(-4, 2)) // de ,截取-从下标倒数第4个(此处也是正数第4个)开始,到最后
console.log(str.substr(-10, 2))//ab 开始位置倒数第10个元素，不存在，位置从0开始，从0到2（不包含2）

8.1.3 substring()

返回一个索引和另一个索引之间的字符串(不改变原字符串),substring(start,end)有两个参数(start必需,end选填),都是索引,返回值不包括end

• 任意参数小于0都视为0,两参数都为负数或两参数相等返回空字符
• 如果 第一个参数 比 第二个参数大，那么该方法在提取子串之前会先交换这两个参数。

var str = "abcdefg";

//任意参数小于0都视为0
console.log(str.substring(-1, 5)) //01234  开始索引为0 结束索引为5(不包括5)

//两参数都为负数或两参数相等返回空字符
console.log(str.substring(-1, -5)) //返回空,0到0

//如果 第一个参数 比 第二个参数大，那么该方法在提取子串之前会先交换这两个参数。
console.log(str.substring(5, 2)) //2到5

8.2 截取数组

1260. 二维网格迁移(javascript)Shift 2D Grid(leetcode)

8.2.1 slice(start,end)

返回一个索引和另一个索引之间的数据(不改变原数组),slice(start,end)有两个参数(start必需,end选填),都是索引,返回值不包括end

var list = ['1', '2', '3', '4', '5', '6', '7', '8'];
console.log(list.slice(1, 4)) //  [ "2", "3", "4" ]开始索引为1 结束索引为4(不包括4)
console.log(list) //['1', '2', '3', '4', '5', '6', '7', '8']不改变原数组

//list.slice(-1, 4)<==>list.slice(7, 4)
console.log(list.slice(-1, 4)) //[]  倒数第一个，即第七个到第四个，没有截取部分，返回空数组
console.log(list.slice(7, 4)) //[]  

//list.slice(-6, 4)<==>list.slice(2, 4)
console.log(list.slice(-6, 4)) //['3', '4']
console.log(list.slice(2, 4)) //['3', '4']

//list.slice(-6)<==>list.slice(2)   第二个参数省略，直接截取到最后一项
console.log(list.slice(-6)) //['3', '4', '5', '6', '7', '8']
console.log(list.slice(2)) //['3', '4', '5', '6', '7', '8']

//开始为负数，同时也不存在时，从0开始截取
console.log(list.slice(-20, 4)) // ['1', '2', '3', '4']
console.log(list.slice(-20)) //['1', '2', '3', '4', '5', '6', '7', '8']

//list.slice(-6, -1) <===>list.slice(2, 7)
console.log(list.slice(-6, -1)) //['3', '4', '5', '6', '7']
//list.slice(-6, -1) <===>list.slice(2, 0) 截取部分不存在，返回空数组
console.log(list.slice(-6, -8)) //[]

// 当起始参数值大于或等于 length 属性值时，将不会执行任何操作，返回空数组。而如果第二个参数值大于 length 属性值时，将被视为 length属性值。
var list = ['1', '2', '3', '4', '5', '6', '7', '8'];
var b = list.slice(3,10);  //截取第四个元素，直到后面所有元素
console.log(b);  //返回[4,5]

8.2.2 splice()

用来添加或者删除数组的数据,只返回被删除的数据,类型为数组(改变原数组)
list.splice(1, 1)返回截取的数组
list返回截取后的数组，原数组改变
list.splice(index,howmany,item1,…itemX)

• index 必须，整数，规定添加，删除项目的位置，使用负数可从数组结尾处规定位置。
• howmany 必须。要删除的项目数量。如果设置为0（小于0也视作0），也不会删除项目

var list = ['1', '2', '3', '4', '5', '6', '7', '8'];
//当只有索引,从当前索引截取到最后
 console.log(list.splice(1, 1)) // ['2']
 console.log(list.splice(1, 0)) // [];
 console.log(list.splice(-2, 2)) // ['7', '8'];
 console.log(list.splice(1, -10)) //[]
 console.log(list.splice(1, 2, ['张龙'], '赵虎', '张三')) // ['3', '4']
 console.log(list) //  ['1', Array(1), '赵虎','张三', '5', '6']
        
var list1 = ['1', '2', '3', '4', '5', '6', '7', '8'];
//当只有索引,从当前索引截取到最后
console.log(list1.splice(1)) //['2', '3', '4', '5', '6', '7', '8']
console.log(list1) // ['1']

9.获得数组中的最大值和最小值

1380. 矩阵中的幸运数（javascript） Lucky Numbers in a Matrix

let list = [2, 4, 5, 2, 4, 3, 2, 8, 1]
console.log(Math.max.apply(Math, list));//8
console.log(Math.min.apply(Math, list));//1
//获取两个数最大值，最小值
console.log(Math.max(1, 2));//2
console.log(Math.min(1, 2));//1

643. 子数组最大平均数 I(javascript)643. Maximum Average Subarray I

10.去除字符串两边的引号

comName = comName.replace(/\"/g, "")

11.Number.MIN_SAFE_INTEGER代表在 JavaScript中最小的安全的integer型数字

let getMax = Number.MIN_SAFE_INTEGER;

643. 子数组最大平均数 I(javascript)643. Maximum Average Subarray I

12.Number.MAX_VALUE 属性表示在 JavaScript 里所能表示的最大数值。

let getMax = Number.MAX_VALUE;

13.entries()：方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。

697. 数组的度(javascript)697. Degree of an Array

1.entries()

  // entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
        // 迭代对象中数组的索引值作为 key， 数组元素作为 value。
        //定义数组
         let arr = ['中文','英文','韩语'];
         arr.entries();//返回一个可迭代数组
        // [0, "中文"]
        // [1, "英文"]
        // [2, "韩语"]
         for(let [index,value] of arr.entries()){
         	//利用数组解构
         	console.log(index,value)
         }

14.Object.values()：返回一个数组，其元素是在对象上找到的可枚举属性值。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

697. 数组的度(javascript)697. Degree of an Array

1.Object.values()

 // Object.values()的用法
 // Object.values(obj)
 // Object.values()返回一个数组，其元素是在对象上找到的可枚举属性值。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。
 var obj = { foo: 'bar', baz: 42 };
 console.log(Object.values(obj)); // ['bar', 42]

15.JavaScript 中的 every() 方法和some() 方法

JavaScript 中的 every() 方法和some() 方法

16.数组常用方法

1.arr.push()

作用：将数据 追加 到数组的 末尾
返回值：追加数据后数组最新的长度
会改变原始数组

let arr =[100,200,300,400]
arr.push(100) //5
arr.push(700) //6
arr //[100, 200, 300, 400, 100, 700]

2.arr.pop()

作用：删除 数组 最后一个 数据
返回值：被删除的数据
会改变原始数组

let arr =[100, 200, 300, 400, 100, 700]
arr.pop()//700 
arr  //[100, 200, 300, 400, 100]

3.arr.unshift()

作用：将数据 添加 到数组的 最前面
返回值：添加数据后数组的最新长度
会改变原始数组

let arr =[100, 200, 300, 400, 100]
arr.unshift('10')//6
arr //['10', 100, 200, 300, 400, 100]

4.arr.shift()

作用：删除 数组 最前一个 数据
返回值：被删除的数据
会改变原始数组

let arr = ['10', 100, 200, 300, 400, 100]
arr.shift()//'10'
arr // [100, 200, 300, 400, 100]

5.arr.reverse()

作用：将数组 反转
返回值：反转后的数组
会改变原始数组

let arr = [100, 200, 300, 400, 100]
arr.reverse()  // [100, 400, 300, 200, 100]
arr // [100, 400, 300, 200, 100]

6.arr.sort()

作用：将数组进行 排序
会改变原始数组

let arr = [11,1,22,13,45,32]
arr.sort((a,b) =>{ return a - b})   //从小到大排序
//arr [1, 11, 13, 22, 32, 45]
arr.sort((a,b) => {return b - a})	 //从大到小排序
//arr  [45, 32, 22, 13, 11, 1]

7.arr.join(‘,’)

语法：数组.join(连接符)
作用： 将数组用 连接符 连接成为一个 字符串
返回值：连接好的字符串
不会改变原数组

let arr = [45, 32, 22, 13, 11, 1]
arr.join(',') //'45,32,22,13,11,1'
arr // [45, 32, 22, 13, 11, 1]
arr.join(';') //'45;32;22;13;11;1'
arr // [45, 32, 22, 13, 11, 1]

9.arr.concat(arr1)

语法：数组.concat(其他数组)
作用：将其他数组和数组 拼接 在一起
返回值：合并好的数组
不会改变原数组

let arr = [45, 32, 22, 13, 11, 1]
let arr1 = [1, 11, 13, 22, 32, 45]
arr.concat(arr1)
//[45, 32, 22, 13, 11, 1, 1, 11, 13, 22, 32, 45]

arr  //[45, 32, 22, 13, 11, 1]
arr1 //[1, 11, 13, 22, 32, 45]

10.arr.includes()

用来判断一个数组是否包含一个指定值，根据情况，如果包含则返回true，否则返回false；

let arr =[1,2,3,4,5,6]
arr.includes(1)//true
arr.includes('1')//false

11.Array.isArray()

用于确定传递的值是否是一个Array；

let arr =[1,2,3,4,5,6]
Array.isArray(arr)//true
let arr =null
Array.isArray(arr)//false
let arr ='1,2,3,4,5,6'
Array.isArray(arr)//false