文章目录
- 数组
- 基本特性
- 常用方法
- leetcode例题
- [217. 存在重复元素](https://leetcode.cn/problems/contains-duplicate/)
- [53. 最大子数组和](https://leetcode.cn/problems/maximum-subarray/)
- [88. 合并两个有序数组](https://leetcode.cn/problems/merge-sorted-array/)
- [1. 两数之和](https://leetcode.cn/problems/two-sum/)
- [350. 两个数组的交集 II](https://leetcode.cn/problems/intersection-of-two-arrays-ii/)
- [121. 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/)
- [566. 重塑矩阵](https://leetcode.cn/problems/reshape-the-matrix/)
- [118. 杨辉三角](https://leetcode.cn/problems/pascals-triangle/)
- [36. 有效的数独](https://leetcode.cn/problems/valid-sudoku/)
- [73. 矩阵置零](https://leetcode.cn/problems/set-matrix-zeroes/)
数组
基本特性
-
JavaScript中已经为我们封装好了较为完善的数组(自动扩容,允许存放不同类型的数据)
-
数组中间插入和删除性能较低,但是查找速度快(下标查找)
常用方法
增/删
方法名 | 说明 | 返回值 |
---|---|---|
unshift(参数1…) | 头增,修改原数组 | 返回新的长度 |
push(参数1…) | 尾增,修改原数组 | 返回新的长度 |
shift() | 头删,修改原数组 | 返回删除元素值 |
pop() | 尾删,修改原数组 | 返回删除元素值 |
修改顺序
方法名 | 说明 | 返回值 |
---|---|---|
reverse() | 翻转数组,修改原数组 | 返回新数组 |
sort() | 直接使用,会将数字当成字符串,只看第一位;回调使用,排序;修改原数组 | 返回新数组 |
// 不能直接使用arr.sort,会按照字符串排序,即按照第一位数字排序
// 必须在里面加个function确定顺序
var arr=[1,20,60,7];
arr.sort() //1,20,60,7
arr.sort(function(a,b){
return(a-b);//升序排列
return(b-a);//降序排列
});
查询
方法名 | 说明 | 返回值 |
---|---|---|
indexOf(参数) | 从前向后找,只找一个 | 第一个满足条件的索引号,不存在返回-1 |
lastIndexOf(参数) | 从后向前找,只找一个 | 第一个满足条件的索引号,不存在返回-1 |
includes(参数,开始位置) | 查找是否存在 | true/false |
连接、截取、过滤、更新
方法名 | 说明 | 返回值 |
---|---|---|
concat() | 连接两个或多个数组,不影响原数组 | 返回新数组 |
slice() | 数组截取slice(begin,end),不影响原数组 | 返回截取部分的新数组 |
filter(item=>item.done) | 不影响原数组 | 返回新数组 |
splice() | 数组更新splice(begin,个数,item1…itemX)第三个参数可选,不填即为截取,会影响原数组 | 返回截取部分的新数组 |
// 注意:splice()、slice()都是顾头不顾尾
var arr=[1,20,60,7];
var newArr = arr.slice(0,3)
console.log(newArr);// [1,20,60]
遍历
- Array.from()
将类数组或可遍历对象转化为真正的数组
Array.from(可遍历对象名)
- forEach(function(value,index,arr) {})
无返回值,对原数组没有影响
arr.forEach(function(value,index,arr) {})
// value当前正在遍历的元素
// index当前正在遍历元素的索引
// arrobj整个数组
- map(function(value,index,arr) {})
支持return返回,对原数组没有影响
array.map(function(value,index,arr), thisValue)
// value 必选。当前元素的值
// index 可选。当前元素的索引值
// arr 可选。当前元素属于的数组对象
// thisValue 可选。对象作为该执行回调时使用,传递给函数,用作 "this" 的值。如果省略了 thisValue,或者传入 null、undefined,那么回调函数的 this 为全局对象。
// 返回一个新数组
// 等同于
function myMap(fn){
//this是调用此方法的数组
let newArr = []
for(let i = 0;i<this.length;i++){
let result = fn(this[i],i,this)
newArr.push(result)
}
return newArr
}
判断条件遍历查询
// callback有三个参数。
// value:每一次迭代查找的数组元素。
// index:每一次迭代查找的数组元素索引。
// arr:被查找的数组。
- every(callback)
所有项都满足条件,返回true
- some(callback)
只要有一项满足条件,就会返回true
- find(callback)
查找符合条件的元素,找到第一个值返回,找不到返回undefined
- findIndex(callback)
查找符合条件的元素,找到第一个值返回其索引,找不到返回-1
注意:find()返回的是值,indexOf()返回的是索引
findIndex比indexOf更强大一些,可以通过回调函数查找对象数组,但indexOf可以指定开始查找位置的索引
数组转字符串
方法名 | 说明 | 返回值 |
---|---|---|
toString() | 把数组转换为字符串,逗号分隔每一项 | 返回一个字符串 |
join(“分隔符”) | 把数组中所有元素转换为一个字符串 | 返回一个字符串 |
leetcode例题
217. 存在重复元素
var containsDuplicate = function(nums) {
let arr = []
for(let i = 0 ; i<nums.length;i++){
if(arr.indexOf(nums[i])==-1){
arr.push(nums[i])
}else{
return true
}
}
return false
};
53. 最大子数组和
最开始想的是直接暴力,将所有结果存在一个数组中,比较得出最大值,但是这样会超过数组存储限制
因此我们使用动态规划
var maxSubArray = function(nums) {
let res = nums[0]
let sum = 0
for(const num of nums){
// 如果和sum大于0,代表对之后有益,继续向后计算
if(sum>0){
sum += num
}else{
// sum小于或等于0,对后面计算不利,直接从当前值开始计算
sum = num
}
// 用旧的res比较新的sum,将较大的赋给res
res = Math.max(res,sum)
}
return res
};
88. 合并两个有序数组
// 思路主要是用数组es6的新方法
// 对n==0和m==0的情况单独进行判断
// 其他即为正常情况,我们使用splice更新数组
// 使用sort排序
var merge = function(nums1, m, nums2, n) {
if(n==0){
return nums1
}else if(m==0){
Object.assign(nums1,nums2)
}else{
nums1.splice(m,nums1.length-m,...nums2)
nums1.sort((a,b)=>{
return(a-b)
})
}
};
1. 两数之和
最基本的双重for循环就不写了
// 使用map
// 遍历数组,用目标值-数组的值求出需要的值
// 将数组中的值作为value,位置作为key存入map
// 找到符合要求的value,就返回对应的key
var twoSum = function(nums, target) {
let map = new Map()
for(let i=0; i<nums.length; i++){
const number = target - nums[i]
if(map.has(number)){
return [map.get(number),i]
}else{
map.set(nums[i],i)
}
}
};
350. 两个数组的交集 II
// 双重for循环,遇到相同的就push进结果
// 同时删除第二个数组的该元素并跳出本次循环
var intersect = function(nums1, nums2) {
const res = []
for(let i=0;i<nums1.length;i++){
for(let j=0;j<nums2.length;j++){
if(nums2[j] == nums1[i]){
res.push(nums2[j])
nums2.splice(j,1)
break
}
}
}
return res
};
// 哈希map
// 使用map,key为nums1的元素,value为该元素出现次数
// 当有次数时遇到与nums2相同的元素,就push到结果中
// 并将次数-1
var intersect = function(nums1, nums2) {
const map = new Map()
const res = []
for(num1 of nums1){
if(map[num1]){
map[num1]++
}else{
map[num1] = 1
}
map.set(num1,map[num1])
}
for(num2 of nums2){
if(map.get(num2)>0){
res.push(num2)
map.set(num2,--map[num2])
}
}
return res
};
121. 买卖股票的最佳时机
注意prices的长度,嵌套for循环必超时
// 贪心算法
// 遍历prices,用当前值减去之前遍历中遇到的最小值等到当前的最大值
// 比较res和当前最大值谁大,将大的赋给res
var maxProfit = function(prices) {
if(prices.length<2) return 0
let max = 0
let minPrice = prices[0]
for(let i=0; i<prices.length;i++){
max = Math.max(max,prices[i]-minPrice)
minPrice = Math.min(prices[i],minPrice)
}
return max
};
566. 重塑矩阵
遇到这个题,我首先想到的思路就是先将二维数组转一维,再进行后面的操作
几种将二维数组转一维的方法(数组扁平化)
// 方法一:遍历,使用concat拼接
const arr1 = [[1,2],[3,4]]
var arr2 = []
for(let i=0;i<arr1.length;i++){
arr2 = arr2.concat(arr1[i])
}
// 方法二:使用apply()
// apply的第一个参数用来修改this指向,传入一个空数组即可
// apply的第二个参数为一个数组,可以作为其调用函数的参数使用(即[].concat调用了apply,使用了参数arr1)
// apply会解开数组参数的第一层[[1,2],[3,4]]-->[1,2],[3,4]
// 此时使用concat即可完成拼接
var arr2 = [].concat.apply([],arr1);
// 方法三:flat(参数)实现数组扁平化
// 参数的意思是需要扁平化的层数
const arr1 = [[1,2],[3,4]]
const arr2 = arr1.flat(1) //二维-->一维,扁平化1层
解题代码
var matrixReshape = function(mat, r, c) {
// 数组拍平
let arr = mat.flat()
let res = []
if(r*c != arr.length){
return mat
}else{
// r行
for(let i=0;i<r;i++){
let item = []
// c列
for(let j=0;j<c;j++){
item.push(arr.shift())
}
res.push(item)
}
return res
}
};
// 调用api,继续简化
function matrixReshape(mat, r, c) {
const arr = mat.flat()
const res = []
if(r*c != arr.length) return mat
for(let i = 0; i < r; i++){
// splice截取数组,返回值为截取部分的数组
res.push(arr.splice(0,c));
}
return res;
};
118. 杨辉三角
// 二维数组动态规划
var generate = function(numRows) {
let arr = [[1]]
// 遍历每行
for(let i=0;i<numRows;i++){
arr[i] = []
arr[i][0] = 1 // 每行首尾都是1
arr[i][i] = 1
for(let j=1;j<i;j++){
// 动态规划,拆分子问题
arr[i][j] = arr[i-1][j-1]+arr[i-1][j]
}
}
return arr
};
36. 有效的数独
为了便于理解,我将横向、纵向和9宫格区域分开判断
- 判断方式:遍历每块区域,如果map中没有该元素,就set进去,如果有,说明重复,返回false
- 遍历方式:横向和纵向的遍历比较简单,不再说明
每个9宫格主要是通过
x = 3*Math.floor((i/3))+Math.floor((j/3))
y = Math.floor(3(i%3))+Math.floor((j%3))来得出每次遍历九宫格的坐标
// 暴力
var isValidSudoku = function(board) {
// 判断每行
for(let row of board){
let map = new Map()
for(let i=0;i<9;i++){
if(row[i] != "."){
if(!map.get(row[i])){
map.set(row[i],1)
}else{
return false
}
}
}
}
// 判断每列
for(let j=0;j<9;j++){
let map = new Map()
for(let col of board){
if(col[j] != "."){
if(!map.get(col[j])){
map.set(col[j],1)
}else{
return false
}
}
}
}
// 判断3*3宫
for(let i=0;i<9;i++){
let map = new Map()
for(let j=0;j<9;j++){
let x = 3*Math.floor((i/3))+Math.floor((j/3))
let y = Math.floor(3*(i%3))+Math.floor((j%3))
if(board[x][y] != "."){
if(!map.get(board[x][y])){
map.set(board[x][y],1)
}else{
return false
}
}
}
}
return true
};
73. 矩阵置零
// 将值为0的横纵坐标存起来
// 再遍历将对应的行列变为0
var setZeroes = function(matrix) {
let row = []
let col = []
for(let i=0;i<matrix.length;i++){
for(let j=0;j<matrix[0].length;j++){
if(matrix[i][j]==0){
row.push(i)
col.push(j)
}
}
}
row.forEach(item=>{
for(let i=0;i<matrix[0].length;i++){
matrix[item][i] = 0
}
})
col.forEach(item=>{
for(let j=0;j<matrix.length;j++){
matrix[j][item] = 0
}
})
return matrix
};