leetcode复习知识点归纳（刷题必不可少）

原创

小哥 3年前 (2022-11-10) 阅读数 46 #大杂烩

leetcode刷题知识点汇总

1.字符串比较localeCompare
2.ES6之数组的flat(Infinity)扁平化以将多维数组转换为一维数组
3.find()，findIndex()，indexOf()，lastindexOf
4.filter
5.map
6.reduce
7.深度优先，宽度优先
8.截取
9.获取数组中的最大值和最小值。
10.删除字符串两侧的引号
11.Number.MIN_SAFE_INTEGER代表在 JavaScript最小的保险箱integer型数字
12.Number.MAX_VALUE 属性表示为 JavaScript 中可以表示的最大值。

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]

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