集合

1，特点

无序且唯一的结构，ES6中用集合用Set

2，操作

• 去重
• 判断元素是否在集合中
• 求交集

3，演示

      const set = new Set();
      set.size; // 值的个数
      set.add(1); // 向Set中添加一个对象；返回该Set对象
      set.clear(); // 移除所有元素
      set.delete(1); // 移除某个元素
      set.has(1); // 是否存在
      // set.entries  set.forEach set.values set.keys  迭代器
      // 转换
      Arry.from(set);  
      new Set([]);

      //  去重
      const arr = [1, 2, 3, 4, 4, 5];
      const arr2 = [...new Set(arr)];

      // 判断元素是否在集合中
      const set1 = new Set(arr);
      set.has(3);

      // 求交集
      const set2 = new Set([2, 3]);
      const set3 = new Set([...set1].filter((item) => set2.has(item)));

4，练习题

349. 两个数组的交集

     //给定两个数组，编写一个函数来计算它们的交集。
    // 用集合对nums1去重，遍历nums1 筛选nums2也包含的值
    
   var intersection = function (nums1, nums2) {
        //return [... new Set(nums1)].filter(item=> new Set(nums2).has(item));
        return [...new Set(nums1)].filter((item) => nums2.includes(item));
   };

字典

1，特点

与集合类似，字典存储唯一值类型的数据结构，是以键值对的形式来存储；ES6中用Map存储；

2，操作

键值对的增删改查；

3，演示

      const map = new Map();
      // 增
      map.set("a", "aa");
      map.set("b", "bb");
      // 改
      map.set("a", "aaa");
      // 查
      map.get("a");
      // 删除
      map.delete("b", "bb");
      map.clear();
      // 键值对的个数
      map.size;
      // 迭代器方法
      map.forEach map.keys map.values map.entries

4，练习题

还是上面349；

      var intersection = function (nums1, nums2) {
        //   return [... new Set(nums1)].filter(item=> new Set(nums2).has(item));
        //  return [... new Set(nums1)].filter(item=> nums2.includes(item));
        const map = new Map();
        nums1.forEach((item) => {
          map.set(item, true);
        });
        const res = [];
        nums2.forEach((item) => {
          if (map.has(item)) { 
            res.push(item);
            map.delete(item);// 删除防止重复
          }
        });
        return res;
      };

20. 有效的括号

      var isValid = function (s) {
        if (s.length % 2 !== 0) return false;
        const stack = [];
        // 建立映射关系
        const map = new Map();
        map.set("(", ")");
        map.set("[", "]");
        map.set("{", "}");
        for (let i = 0; i < s.length; i++) {
          let str = s[i];
          if (map.has(str)) {
            stack.push(str);
          } else {
            const temp = stack[stack.length - 1];
            if (map.get(temp) === str) {
              stack.pop();
            } else {
              return false;
            }
          }
        }
        return stack.length === 0;
      };
      

1. 两数之和

    // 用字典建立一种映射关系；把需要的坐标和自己的坐标建立映射关系；
      var twoSum = function (nums, target) {
        const map = new Map();
        for (let i = 0; i < nums.length; i++) {
          let temp = nums[i];
          let current = target - temp;
          if (map.has(temp)) { // 有需要的返回
            return [map.get(temp), i];
          } else {
            map.set(current, i); // 没有需要的登记
          }
        }
      };

3. 无重复字符的最长子串

  // 用双指针维护一个滑动窗口，用来剪切子串
  // 不断右移动指针，避免重复字符，就把左指针移动到重复字符的下一位
  // 过程中，记录所有窗口的长度，并返回最大值
  var lengthOfLongestSubstring = function (s) {
    let l = 0;
    let max = 0;
    const map = new Map();
    for (let r = 0; r < s.length; r++) {
      if (map.has(s[r]) && map.get(s[r]) >= l) {
        l = map.get(s[r]) + 1;
      }
      map.set(s[r], r);
      max = Math.max(max, r - l + 1);
    }
    return max;
  };

76. 最小覆盖子串

//  用双指针维护一个滑动窗口
//  移动右指针，找到包含T的子串，移动左指针，尽量减少包含T的子串的长度；
var minWindow = function(s, t) {
    let map = new Map();
    for (let i= 0; i<t.length;i++) {
        const val = t[i];
        map.set(val,map.has(val)?map.get(val)+1:1)
    }
    let size = map.size;
    let l = 0;
    let r = 0;
    let str = '';
    while(r<s.length){
        let cr = s[r];
        if (map.has(cr)) {
            map.set(cr,map.get(cr)-1);
            if (map.get(cr)===0) size--; 
        }
        while(size===0) {
            const newStr = s.substring(l,r+1);
            if (str) {
                str = newStr.length<str.length?newStr:str;
            }else {
                str = newStr;
            }
            const cl = s[l];
            if (map.has(cl)) {
                map.set(cl,map.get(cl)+1);
                if (map.get(cl)===1) size++;
            }
            l++;
        }
        r++;
    }
    return str;
};