【hot100】力扣hot100部分题解

1.和为k的子数组
题目链接
注意：题目是连续的子数组。
因为数据有负数，用滑动窗口不太好做。
所以用数组前缀和。
数组前缀和就是从第1位到当前位的子数组的和。
每次遍历更新到当前位之前的前缀和，以对象的形式存储（key为前缀和，value为该前缀和的个数）
同时每次遍历看一下当前位前缀和-k是否在对象中存在，意思是：如果存在就证明，当前位和之前某一位的前缀和的差值为k，即存在一段子数组和为k。所以count就加上对象存储的值，也就是有几个子数组和为k。

var subarraySum = function(nums, k) {
    let preSum=0;
    let obj={};
    obj[0]=1;
    let count=0;
    for(let num of nums){
        preSum+=num;
        if(obj[preSum-k]){
            count+=obj[preSum-k];
        }
        if(obj[preSum]){
            obj[preSum]=obj[preSum]+1;
        }
        else {
            obj[preSum]=1;
        }
    }
    return count;
};

2.LRU缓存
题目链接
用map保存key
无论是get还是put方法，都是使用了它，相当于最近的更新。所以无论get还是put方法，我们都可以把对应的key value删除，再重新插入一份，这样他在最底下，也就相当于最新更新，如果put超过了最大容量，就把最上面的key value删掉（也就是最旧没更新的数据）。

这里的删除map中的第一个值，使用this.map.delete(this.map.keys().next().value)。

map.keys()拿到map对应的key的值（[Map Iterator]迭代器）
如：[Map Iterator] { 1, 2 }
this.map.keys().next()拿到迭代器中的第一项（有对应的value属性和done属性）
如：{ value: 1, done: false }
this.map.keys().next().value拿到对应的value值
如：1

力扣写法：

/**
 * @param {number} capacity
 */
var LRUCache = function(capacity) {
    this.capacity=capacity;
    this.map=new Map(this.capcity);
};

/** 
 * @param {number} key
 * @return {number}
 */
LRUCache.prototype.get = function(key) {
    let value=this.map.get(key);
    if(value===undefined)return -1
    else{
        this.map.delete(key);
    }
    this.map.set(key,value);
    return value;
};

/** 
 * @param {number} key 
 * @param {number} value
 * @return {void}
 */
LRUCache.prototype.put = function(key, value) {
    let lastvalue=this.map.get(key);
    if(lastvalue){
        this.map.delete(key);
    }
    this.map.set(key,value);
    if(this.map.size>this.capacity){
        this.map.delete(this.map.keys().next().value)
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * var obj = new LRUCache(capacity)
 * var param_1 = obj.get(key)
 * obj.put(key,value)
 */

类写法：

class LRUCache {
  constructor(num){
    this.capacity=num;
    this.map=new Map(this.capcity);
  }
  put(key,value){
      let lastvalue=this.map.get(key);
      if(lastvalue){
          this.map.delete(key);
      }
      this.map.set(key,value);
      if(this.map.size>this.capacity){
          this.map.delete(this.map.keys().next().value)
      }
  }
  get(key){
    let value=this.map.get(key);
    if(value){
        this.map.delete(key);
    }else return -1;
    this.map.set(key,value);
    return value;
  }
}
let  lRUCache = new LRUCache(2);
lRUCache.put(1, 0); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

3.轮转数组
题目链接
这题没什么说的，注意一点，k有可能大于nums的长度，如果大于，k其中的nums.length次轮转最后的结果实际上又变回原始位置，所以只需要轮转k%nums.length次即可。

var rotate = function(nums, k) {
    if(nums.length<k){
        k=k%nums.length;
    }
    let temp=nums.slice(nums.length-k);
    nums.splice(nums.length-k,k);
    nums.splice(0,0,...temp);
};