数据结构之“字典”

字典是什么？

• 与集合类似，字典也是一种存储唯一值的数据结构，但它是以键值对的形式来存储
• ES6中有字典，名为Map
• 字典的常用操作：键值对的增删改查

字典常用方法

const m = new Map()
//增
m.set('a','aa');
m.set('b','bb');
//改
m.set('a','aaa');
//删
m.delete('b');
m.clear();

LeetCode:349.两个数组的交集

解题思路

• 求nums1和nums2都有的值
• 用字典建立一个映射关系，记录nums1里有的值
• 遍历nums2，找出nums1里也有的值 解题步骤
• 新建一个字典，遍历nums1,填充字典
• 遍历nums2,遇到字典里的值就选出，并从字典中删除 coding

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
 
//下面是字典Map的做法
var intersection = function(nums1, nums2) {
    let map = new Map();
    nums1.forEach(n=>{
        map.set(n,true);//有相同的数字n，并不会重复添加
    });
    let res = [];
    nums2.forEach(n=>{
        if(map.get(n)){
            res.push(n);
            map.delete(n);
        }
    })
    return res;

};

时间复杂度：O(m+n),空间复杂度O(m)

LeetCode:20. 有效的括号

coding

/**
 * @param {string} s
 * @return {boolean}
 */
/**使用字典 MAP */

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

时间复杂度：O(n),空间复杂度O(1)

LeetCode:1. 两数之和

coding

/**暴力枚举
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
/**用字典Map  (哈希法) */
var twoSum = function(nums, target) {
    let map = new Map();
    for(let i = 0;i < nums.length;i++){
        let n = nums[i];
        let n2 = target - n;
        if(map.has(n2)){
            return [map.get(n2),i];
        }else{
            map.set(n,i);
        }
    }
}

时间复杂度：O(n),空间复杂度O(n)

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

解题思路

• 先找出所有的不包含重复字符的子串
• 找出长度最大那个子串，返回其长度即可 解题步骤
• 用双指针维护一个滑动窗口，用来剪切子串
• 不断移动右指针，遇到重复字符，就把左指针移动到重复字符的下一位
• 过程中，记录所有窗口的长度，并返回最大值 coding

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function(s) {
    let left = 0;
    let res = 0;
    const map = new Map();
    for(let right = 0; right < s.length; right++){
        if(map.has(s[right]) && map.get(s[right]) >= left){
            left = map.get(s[right]) + 1;
        }
        res = Math.max(res,right - left + 1);
        map.set(s[right],right);
    }
    return res;
};

时间复杂度：O(n),空间复杂度O(m) m是字符串中不重复字符的个数