力扣算法之哈希表

哈希表

1. 理论

一般哈希表都是用来快速判断一个元素是否出现集合里

1.1 哈希结构

• 数组
• set （集合）
• map(映射)

1.2 数组

1.3 set集合

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(log n)	O(log n)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

• std::unordered_set底层实现为哈希表
• std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

1.4 Map集合

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(log n)	O(log n)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

• std::unordered_map 底层实现为哈希表
• std::map 和std::multimap 的底层实现是红黑树 同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）

1.5 总结

• 当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。
• 但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。
• 如果在做面试题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！

2. Leetcode题集

2.1 三数之和 M

2.1.1 双指针解法

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();//定义一个结果集
        //对数组排序
        Arrays.sort(nums);
        //for循环遍历
        for (int i = 0; i < nums.length; i++) {
            //排序后若第一个元素已经大于0，无论怎么组合都不可能凑成三元组，直接返回结果
            if (nums[i]>0){
                return result;
            }
            //去重a
            if (i>0&&nums[i]==nums[i-1])
                continue;

            //双指针
            int left=i+1,right=nums.length-1;

            while (right>left){
                //和
                int sum=nums[i]+nums[left]+nums[right];
                //对和进行讨论
                //若和大于0，移动right向左使其减小
                if (sum>0){
                    right--;
                }else if (sum<0){
                    left++;
                }else {
                    result.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    //最后对b、c去重  去重在获取三元组之和
                    while (right>left&&nums[right]==nums[right-1]) right--;//right-1 不能right-- 下同
                    while (right>left&&nums[left]==nums[left+1]) left++;

                    //找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
}

2.1.2 去重逻辑

• a的去重

  • 以下两段代码区别：

    针对三元组{a,b,c}，以下代码，第二行代码相同数的第一位b仍能取到和a相同的数，而第一行代码直接排除；

    nums[i]==nums[i-1]
    nums[i]==nums[i+1]//用此代码
    

  我们要做的是 不能有重复的三元组，但三元组内的元素是可以重复的！

• b与c的去重

  • 去重逻辑应该放在找到一个三元组之后，对b 和 c去重

    while (right > left && nums[right] == nums[right - 1]) right--;
    while (right > left && nums[left] == nums[left + 1]) left++;
    

2.2 四数之和 M

2.2.1 双指针解法

• 在三数之和基础上，套一层for循环

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();//定义一个结果集
        //对数组排序
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            //1级剪枝处理
            //这里要添加nums[i]>target 跟三数相加有所不同，这里不是0是target
            if (nums[i] > 0 && nums[i] > target) {
                return res;
            }
            //去重i
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            //接下来类似三数相加
            for (int j = i + 1; j < nums.length; j++) {
                //去重j
                if (j > i + 1 && nums[j] == nums[j - 1])
                    continue;

                int left = j + 1, right = nums.length - 1;
                while (right > left) {
                    long sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        //去重right left
                        while (right > left && nums[right] == nums[right-1]) right--;
                        while (right > left && nums[left] == nums[left+1]) left++;

                        //找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }
            }
        }
        return res;
    }
}

• 难在一层的剪枝和去重