【跟着labuladong刷力扣】力扣刷题-----数据结构之数组

前言

刷题学框架,刷题学思想.跟着labuladong刷数组。
labuladong链接:labuladong代码小抄
刷题插件链接(来源labuladong公众号):
链接：https://pan.baidu.com/s/1glrZjyFCG4bXual3gzTvvw
提取码：un2k

---

---

一、小而美的算法技巧：前缀和数组

1、力扣303题：区域和检索 - 数组不可变（简单）

这个问题可以用最简单的方法来实现，但是要不断调用NumArray

var NumArray = function(nums){
    this.nums = nums
}

NumArray.prototype.sumRange = function(left, right) {
    var res = 0
    for(var i = left;i<right+1;i++){
        res += this.nums[i]
    }
    return res
};

如果考虑效率的问题，尽可能把和的实现写在NumArray中，这样可以减少NumArray的调用次数。

var NumArray = function(nums){
    const l = nums.length
    this.preSum = new Array(l+1).fill(0)
    for(var i=0;i<l;i++){
        this.preSum[i+1] = this.preSum[i]+nums[i]
    }
}

NumArray.prototype.sumRange = function(left, right) {
    return this.preSum[right+1]-this.preSum[left]
};

2、力扣304题：二维区域和检索 - 矩阵不可变（中等）

思路也是维护一个行列都+1的二维数组，其中每个ij对应的值为（0，0，i，j）组成的矩阵数字和。注意要减去重复算的左上角的矩形数字和。

var NumMatrix = function(nums){
    l1 = nums.length
    l2 = nums[0].length
    if(l1==0 || l2==0) return
    this.newNums = new Array()
    for(var i=0;i<l1+1;i++){
        var j = new Array(l2+1).fill(0)
        this.newNums.push(j)
    }
    for(var i=1;i<l1+1;i++){
        for(var j=1;j<l2+1;j++){
            this.newNums[i][j] = this.newNums[i-1][j]+this.newNums[i][j-1]+nums[i-1][j-1]-this.newNums[i-1][j-1]
        }
    }
    console.log(this.newNums)
}

NumMatrix.prototype.sumRegion = function(row1, col1, row2, col2) {
    return this.newNums[row2+1][col2+1]-this.newNums[row2+1][col1]-this.newNums[row1][col2+1] + this.newNums[row1][col1]
};

3、力扣560题：和为K的子数组（中等）

本题也用前缀解决，构建前缀数据的方式如下（来自labuladong）:

如果用两个for循环寻找相同值的话，会造成时间超时

var subarraySum = function(nums, k) {
    var l = nums.length
    var newNums = new Array(l+1).fill(0)
    var mp = new Map()
    mp.set(0,0)
   for(var i=1;i<l+1;i++){
        mp.set(nums[i-1] + newNums[i-1],nums[i-1])
   }
   var count = 0
   console.log(newNums)
   for(var i=l;i>0;i--){
       var find = newNums.slice(0,i).filter(item=>{
           return item == newNums[i] - k
       })
       count += find.length
   }
   return count
};

官方解答中使用的是map，这样可以一边创建一边寻找，不需要两个嵌套的for循环了，

var subarraySum = function(nums, k) {
    const mp = new Map();
    mp.set(0, 1);
    let count = 0, pre = 0;
    for (const x of nums) {
        pre += x;
        if (mp.has(pre - k)) {
            count += mp.get(pre - k);
        }
        if (mp.has(pre)) {
            mp.set(pre, mp.get(pre) + 1);
        } else {
            mp.set(pre, 1);
        }
    }
    return count;
};

// 作者：LeetCode-Solution
// 链接：https://leetcode-cn.com/problems/subarray-sum-equals-k/solution/he-wei-kde-zi-shu-zu-by-leetcode-solution/
// 来源：力扣（LeetCode）
// 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

---

二、小而美的算法技巧：差分数组

差分数组主要的适用的场景就是频繁地对原始数据的某个区间的元素进行增减。比如要分不同的次数给数组的1-3减5，再给数据的2-4减6，再做很多类似的操作，如果循环的话效率就会很低，因此可以构建一个差分数组，数组中存储的值为nums[i] - nums[i-1]，当要给i到j的数字＋5时，就给差分数组中的diff[i]+5,diff[j+1]-5。

这么做的原因是什么呢？因为diff[i] = nums[i] - nums[i-1]，因此，nums[i] = diff[i]+nums[i-1]，这样，由于diff[i]做了更改，因此nums[i]也会做更改，然而nums[i+1] = diff[i+1]+nums[i]，因为nums[i]做了更改，所以nums[i+1]也做了更改，一次类推。。。。。到第一个不需要更改的数字时，nums[j+1] = diff[j+1]+nums[j]，这里的nums[j]已经做了更改，那为了nums[j+1]不做更改，diff[j+1]只能反向更改。哇塞，打出来好乱，直接看看图吧。

1、力扣1109题：航班预订统计

明显是一道使用差分数组的题，不需要怎么解释了，只需要维护好一个diff数组即可。

var corpFlightBookings = function(bookings, n) {
    var answer = new Array(n+1).fill(0)
    var diff = new Array(n+1).fill(0)
    for(var site of bookings){
        diff[site[0]] += site[2]
        if(site[1]+1 <= n){
            diff[site[1]+1] -= site[2]
        }
    }
    for(var i=1;i<n+1;i++){
        answer[i] = answer[i-1]+diff[i]
    }
    return answer.slice(1,n+1)
};

2、力扣1094题：拼车

本题也是明显使用差分数组，但需要注意的是，乘客在to位置上的时候已经下车，所以每来一位乘客修改的位置都应该是i~(j-1)。

var carPooling = function(trips, capacity) {
    var stations = new Array(1001).fill(0)
    var diff = new Array(1001).fill(0)
    for(var trip of trips){
        diff[trip[1]+1] += trip[0]
        if(trip[2]+1 < 1001){
            diff[trip[2]+1] -= trip[0]
        }
    }
    for(var i=1;i<1001;i++){
        stations[i] = stations[i-1] + diff[i]
        if(stations[i] > capacity) return false
    }
    return true
};

---

三、双指针技巧秒杀七道数组题目

1、力扣26题：删除有序数组中的重复项

大致思路就是采用快慢指针的方法：
初始状态是slow=0;fast=1;
如果当前位置nums[slow] != nums[fast]，那么证明是不同的数字，令nums[++slow] = nums[fast]
否则fast需要继续向前探路，fast++

var removeDuplicates = function(nums) {
    var slow = 0
    var fast = slow+1
    while(fast < nums.length){
        if(nums[slow] != nums[fast]){
            nums[++slow] = nums[fast]
        }
        fast++
    }
    return slow+1
};

2、力扣27题：移除元素

思路和上一题相同，直接给代码：

var removeElement = function(nums, val) {
    var slow = 0;
    var fast = 0;
    while(fast < nums.length){
        if(nums[fast] != val){
            nums[slow++] = nums[fast]
        }
        fast++
    }
    return slow
};

3、力扣167题：两数之和Ⅱ

如果用暴力

var twoSum = function(numbers, target) {
    for(var i=0;i<numbers.length-1;i++){
        for(var j=i+1;j<numbers.length;j++){
            if(numbers[i]+numbers[j]==target){
                return [i+1,j+1]
            }
        }
    }
};

如果用左右指针

var twoSum = function(numbers, target) {
    var left = 0
    var right = numbers.length-1
    while(left<right){
        if(numbers[left]+numbers[right] == target){
            return [left+1,right+1]
        }
        if(numbers[left]+numbers[right] < target){
            left++
        }else{
            right--
        }
    }
};

4、力扣244题：反转字符串

var reverseString = function(s) {
    var temp = 0
    var left=0;
    var right=s.length-1
    while(left<right){
        temp = s[left]
        s[left] = s[right]
        s[right] = temp
        left++
        right--
    }
    return s
};

5、力扣5题：最长回文字符串

单独构造一个专门判断回文字符串的函数，注意，单双的情况都要考虑。 再用循环依次寻找最长的回文字符串。

var longestPalindrome = function(s) {
    var maxStr = ""
    for(var i=0;i<s.length;i++){
        var str1 = palindrome(s,i,i)
        var str2 = palindrome(s,i,i+1)
        maxStr = str1.length > maxStr.length?str1:maxStr
        maxStr = str2.length > maxStr.length?str2:maxStr
    }
    return maxStr
};

var palindrome = function(s,l,r){
    while(l>=0 && r<s.length && s[l]==s[r]){
        l--;
        r++
    }
    return s.substring(l+1,r)
}

与暴力做法相比，这种方法执行用时明显缩短。