ES6 字典(Map)

这是我参与8月更文挑战的第4天，活动详情查看：8月更文挑战

ES6字典Map, 是一种存储惟一值的数据结构，也是以键值对的形式来存储的。 为了弥补javascript默认的对象 key只能是字符串或者 Symbols。 Map结构的Key能够是任意类型。

Map 和 Object 的区别

• Key: Object只能是string 或者 symbol 类型做为Key.
• 属性顺序: Map中的键值是有序的，而Object不是
• size: Map中键值对个数能够用size获取，而Object要手动计算

基本方法

let myMap = new Map()

myMap.set(1, 1)
myMap.set('a', 'a')

myMap.get(1)

myMap.delete(1);
myMap.clear() // {}


复制代码

刷几道LeetCode感觉一下吧

LeetCode-349: 数组的交集

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

来源：力扣（LeetCode）
复制代码

/** * @param {number[]} nums1 * @param {number[]} nums2 * @return {number[]} */
var intersection = function(nums1, nums2) {
    const map = new Map()
    nums1.forEach(n => {
        map.set(n, true)
    })
    const res = []
    nums2.forEach(n => {
        if (map.get(n)) {
            res.push(n)
            map.delete(n)
        }
    })
    return res
};
复制代码

LeetCode-20: 有效的括号

**示例 1：**

输入： s = "()"
输出： true

**示例 2：**

输入： s = "()[]{}"
输出： true

提示： 
   `s` 仅由括号 `'()[]{}'` 组成
复制代码

/** * @param {string} s * @return {boolean} */


var isValid = function(s) {
    const len = s.length
    if (len % 2 !== 0) return false
    const stack = []
    const map = new Map()
    
    // 将左括号 与 右括号 分别做为 map 的键值对
    map.set('(', ')')
    map.set('[', ']')
    map.set('{', '}')
    
    for (let i = 0; i < s.length; i ++) {
        const c = s[i];
        if (map.has(c)) {
            // 左括号就入栈
            stack.push(c)
        } else {
            // 碰见右括号就须要 对比一下
            const t = stack[stack.length - 1]
            if (map.get(t) === c) {
                stack.pop()
            } else {
                return false
            }
        }
    }
    
    return stack.length === 0
};

复制代码

LeetCode-1: 两数之和

/** * @param {number[]} nums * @param {number} target * @return {number[]} */
var twoSum = function(nums, target) {

    const map = new Map()
    for (let i = 0; i < nums.length; i ++) {
        const n = nums[i]
        const n2 = target - n
        if (map.has(n2)) {
            return [map.get(n2), i]
        } else {
            map.set(n, i) // 设置当前元素的值和下标
        }
    }

};
复制代码

LeetCode-3: 无重复子串长度

/** * @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++) {
        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
};
复制代码

LeetCode-76: 最小覆盖子串

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
示例 2：

输入：s = "a", t = "a"
输出："a"
示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
所以没有符合条件的子字符串，返回空字符串。

来源：力扣（LeetCode)
复制代码

/** * @param {string} s * @param {string} t * @return {string} */
var minWindow = function(s, t) {
    let l = 0;
    let r = 0;
    const need = new Map()
    for (let c of t) {
        need.set(c, need.has(c) ? need.get(c) + 1 : 1)
    }
    // need{A->1, B->1, C->1}， 设置每一个字符须要的个数

    let needType = need.size;
    let res = ""
    while(r < s.length) {
        const c = s[r]
        // 移动右指针
        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(1, 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
};
复制代码