集合

什么是集合？

一种无序且唯一的数据结构 ES6集合：Set

常用操作

去重，判断某元素是否存在，交集。。。

let set1 = new Set();

//add
set1.add(1)
set1.add(5)
set1.add(2)
set1.add(1)
set1.add(5)
console.log(set1);//152
set1.add('111')
set1.add('222')
set1.add('aaa')
let o = {a:1,b:2}
set1.add(o)
set1.add({a:1,b:2})
console.log(set1);

//has
console.log(set1.has(1));
console.log(set1.has(3));//false
console.log(set1.has('111'));
console.log(set1.has(o));

//delete
set1.delete(5)
console.log(set1);

//size
console.log(set1.size);//7
console.log('========================');
//迭代
for(let item of set1){
    console.log(item);
}
console.log('========================');
//entries
for(let [key,value] of set1.entries()){
    console.log(key,value);
}

console.log('========================');

//set array 互转
const arr1 = [...set1]
console.log(arr1);
const arr2 = Array.from(set1)
console.log(arr2);

const set2 = new Set([1,2,3,4,5])
console.log(set2);

console.log('========================');

//交集
const interSetion = new Set([...set1].filter(i => set2.has(i)))
console.log(interSetion);

//差级 set2有，set1没有
const interSetion1 = new Set([...set1].filter(i => !set2.has(i)))
console.log(interSetion1);

字典

什么是字典？

存储唯一值的数据结构,已键值对的方式 ES6 Map

const m = new Map()
//增
m.set('a','aa')
m.set('b','bb')
m.set('c','cc')
console.log(m);

//删
m.delete('b')
console.log(m);
m.clear()
console.log(m);

m.set('a','aa')
m.set('b','bb')
m.set('c','cc')

//改
m.set('a','aaa')
console.log(m);

//查
console.log(m.get('a'));

交集

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
 var intersection = function(nums1, nums2) {
    const m = new Map()
    nums1.forEach(i => {
        m.set(i,true)
    })
    console.log(m)
    const res = []
    nums2.forEach(i => {
        if(m.get(i)){
            res.push(i)
            m.delete(i)
        }
    })
    return res
 };

俩数之和

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
 var twoSum = function(nums, target) {
    const m = new Map()
    let res = []
    nums.forEach((item,index) => {
        const i = target - item
        if(m.has(i)){
            res = [m.get(i),index]
            return
        }
            m.set(item,index)
        
    })

    return res
};

无重复字符串

/**
 * @param {string} s
 * @return {number}
 */
 var lengthOfLongestSubstring = function (s) {
    let l = 0;
    let res = 0;
    const map = new Map()
    for(let r = 0; r < s.length; r+=1){
        //滑动窗口的由指针必须大于左指针
        if(map.has(s[r]) && map.get(s[r]) >= l){
            l = map.get(s[r]) + 1
        }
        res = Math.max(res,r-l+1);
        map.set(s[r],r)
    }

    return res;
};

最小覆盖子串

/**
 * @param {string} s
 * @param {string} t
 * @return {string}
 */
 var minWindow = function (s, t) {
    //找出所有包含t的子串，返回最小的
    let l = 0;
    let r = 0;
    let need = new Map()
    for (let c of t) {
        //遍历放进字典中
        need.set(c, need.has(c) ? need.get(c) + 1 : 1)
    }
    let needType = need.size
    let res = ''
    //移动右指针
    while (r < s.length) {
        const c = s[r]
        //如果在map中就将对应的value减1
        if (need.has(c)) {
            need.set(c, need.get(c) - 1)
            if (need.get(c) === 0) needType -= 1;
        }

        //需求都做完了
        while (needType === 0) {
            //尽可能减小长度
            const newRes = s.substring(l,r+1)
            if(!res || newRes.length < res.length) res = newRes
            const c2 = s[l]
            if (need.has(c2)) {
                need.set(c2, need.get(c2) + 1)
                if (need.get(c2) === 1) needType += 1
            }
            l += 1

        }

        r += 1

    }
    return res
};