概念

与集合类似，字典也是用来存储唯一值的数据结构，但它是以键值对的形式来存储

Es6当中有字典这种数据结构，名字是Map

字典常用的操作：键值对的增删改查

字典常用操作

let myMap =new Map();

//增
myMap.set('a','aaa');

//删
myMap.delete('a')

//改
myMap.set('a','bbb')

求数组交集（使用字典）

var intersection = function(nums1, nums2) {
    let res=[];
    let myMap=new Map();
    nums1.forEach(item=>myMap.set(item,true))
    nums2.forEach(
        item=>{if(myMap.get(item)){
         res.push(item);
         myMap.delete(item);}})
   return res
};

括号判断（使用字典）

var isValid = function(s) {
    const length=s.length;
    if(length %2===1)return false;
    let stack=[];
    let myMap=new Map();
    myMap.set('(',')');
    myMap.set('[',']');
    myMap.set('{','}');
    for(let i=0;i<length;i++){
      let n=s[i];
      if(myMap.has(n)){
          stack.push(n);
      }else {
       const t=stack[stack.length-1];
       if(myMap.get(t)===n){stack.pop();}
       else{ return false}}
    }
    return stack.length===0
};

两数之和

var twoSum = function(nums, target) {
    let map=new Map();
    const length=nums.length;
    for(let i=0;i<length;i++){
        const n1=nums[i];
        const n2=target-n1;
        if(map.has(n2)){
            return [map.get(n2),i]
        }
        else{
            map.set(n1,i);
        }
    }

};

无重复字符最长子串的长度

var lengthOfLongestSubstring = function(s) {
    let l=0;
    let res=0;
    let map=new Map();
    let length=s.length;
    for(let i=0;i<length;i++){
        let n=s[i];
        if(map.has(n)&&map.get(n)>=l){
            l=map.get(n)+1;
        }
        res=Math.max(res,i-l+1);
        map.set(n,i);
    }
   return res
};

最小覆盖子串

var minWindow = function(s, t) {
    let l=0;
    let r=0;
    let need=new Map();
    for(let i of t){
        need.set(i,need.get(i)? need.get(i)+1:1);
    }
    let length=s.length;
    let nodeType=need.size;
    let res='';
    while(r<length){
     let n=s[r];
     if(need.has(n)){
         need.set(n,need.get(n)-1);
        if(need.get(n)===0){nodeType--;}
     }
     while(nodeType==0){
        const newRes=s.substring(l,r+1);
        if(!res||newRes.length<res.length){res=newRes}
        let a=s[l];
        if(need.has(a)){
            need.set(a,need.get(a)+1);
            if(need.get(a)===1) nodeType++;
        }
        l++;
     }
      
     r++;
    }
    return res
};