LeetCode-题目详解（八）：哈希表【Python：dict = {}】【C++：unordered_map＜int, int＞ map】

已于 2023-01-02 11:23:28 修改
阅读量285 收藏
点赞数
文章标签： 算法 哈希表
于 2021-05-13 22:57:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013250861/article/details/116770228
版权

这里写目录标题

剑指 Offer 50. 第一个只出现一次的字符

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。

示例 1:

输入：s = "abaccdeff"
输出：'b'

示例 2:

输入：s = "" 
输出：' '

限制：

  • 0 <= s 的长度 <= 50000
class Solution {
public:
    char firstUniqChar(string s) {
        unordered_map<char, int> map;
        for(char c : s){
            map[c]++;
        }

        for(char c : s){
            if(map[c] == 1){
                return c;
            }
        }
        return ' ';
    }
};

class Solution:
    def firstUniqChar(self, s: str) -> str:
        dict = {}
        for c in s:
            dict[c] = dict.get(c, 0) + 1
        
        for c in s:
            if dict[c] == 1:
                return c
        return " "

49. 字母异位词分组

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

示例 2:

输入: strs = [""]
输出: [[""]]

示例 3:

输入: strs = ["a"]
输出: [["a"]]

提示：

  • 1 <= strs.length <= 1 0 4 10^4 104
  • 0 <= strs[i].length <= 100
  • strs[i] 仅包含小写字母
class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        dict = {}
        result = []

        for s in strs:
            key = ''.join(sorted(s))
            if dict.get(key) != None:
                dict[key].append(s)
            else:
                dict[key] = [s]

        for value in dict.values():
            result.append(value)

        return result

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> mp;
        for(string& str : strs){
            string key = str;
            sort(key.begin(), key.end());
            mp[key].push_back(str);
        }

        vector<vector<string>> result;
        for(auto it = mp.begin(); it != mp.end(); it++){
            result.push_back(it->second);
        }
        return result;
    }
};

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> mp;
        for(string str : strs){
            string key = str;
            sort(key.begin(), key.end());
            mp[key].push_back(str);
        }

        vector<vector<string>> result;
        for(auto it = mp.begin(); it != mp.end(); it++){
            result.push_back(it->second);
        }
        return result;
    }
};

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> mp;
        for(auto str : strs){
            auto key = str;
            sort(key.begin(), key.end());
            mp[key].push_back(str);
        }

        vector<vector<string>> result;
        for(auto it = mp.begin(); it != mp.end(); it++){
            result.push_back(it->second);
        }
        return result;
    }
};

169. 多数元素【剑指 Offer 39. 数组中出现次数超过一半的数字】

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

输入：nums = [3,2,3]
输出：3

示例 2：

输入：nums = [2,2,1,1,1,2,2]
输出：2

提示：

  • n == nums.length
  • 1 < = n < = 5 ∗ 1 0 4 1 <= n <= 5 * 10^4 1<=n<=5∗104
  • − 1 0 9 < = n u m s [ i ] < = 1 0 9 -10^9 <= nums[i] <= 10^9 −109<=nums[i]<=109

思路

我们知道出现次数最多的元素大于 ⌊ n 2 ⌋ \lfloor \dfrac{n}{2} \rfloor ⌊2n​⌋ 次，所以可以用哈希表来快速统计每个元素出现的次数。

算法

我们使用哈希映射（HashMap）来存储每个元素以及出现的次数。对于哈希映射中的每个键值对，键表示一个元素，值表示该元素出现的次数。

我们用一个循环遍历数组 nums 并将数组中的每个元素加入哈希映射中。在这之后，我们遍历哈希映射中的所有键值对，返回值最大的键。我们同样也可以在遍历数组 nums 时候使用打擂台的方法，维护最大的值，这样省去了最后对哈希映射的遍历。

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int, int> count;
        int majority = 0;
        int cnt = 0;

        for(int num : nums){
            count[num]++;
            if(count[num] > cnt){
                majority = num;
                cnt = count[num];
            }
        }

        return majority;
    }
};

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        count = {}
        majority = 0
        cnt = 0

        for i in range(len(nums)):
            num = nums[i]
            count[num]  = count.get(num, 0) + 1
            if count[num] > cnt:
                majority = num
                cnt = count[num]

        return majority

217. 存在重复元素

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

示例 1：

输入：nums = [1,2,3,1]
输出：true

示例 2：

输入：nums = [1,2,3,4]
输出：false

示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2]
输出：true

提示：

  • 1 < = n u m s . l e n g t h < = 1 0 5 1 <= nums.length <= 10^5 1<=nums.length<=105
  • - 1 0 9 < = n u m s [ i ] < = 1 0 9 10^9 <= nums[i] <= 10^9 109<=nums[i]<=109
class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        dict = {}
        for num in nums:
            if dict.get(num) is not None:
                return True
            dict[num] = 1
        return False

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int, int> map;
        for(int num : nums){
            if(map[num] == 1){
                return true;
            }
            map[num] = 1;
        }
        return false;
    }
};

219. 存在重复元素 II

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,1], k = 3
输出：true

示例 2：

输入：nums = [1,0,1,1], k = 1
输出：true

示例 3：

输入：nums = [1,2,3,1,2,3], k = 2
输出：false

提示：

  • 1 < = n u m s . l e n g t h < = 1 0 5 1 <= nums.length <= 10^5 1<=nums.length<=105
  • − 1 0 9 < = n u m s [ i ] < = 1 0 9 -10^9 <= nums[i] <= 10^9 −109<=nums[i]<=109
  • 0 < = k < = 1 0 5 0 <= k <= 10^5 0<=k<=105
class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        dict = {}
        for idx, val in enumerate(nums):
            if dict.get(val) is not None and abs(dict.get(val) - idx) <= k:
                return True
            dict[val] = idx
        return False

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        for(int i = 0; i < nums.size(); i++){
            if(map.count(nums[i]) && i - map[nums[i]] <= k){
                return true;
            }
            map[nums[i]] = i;
        }
        return false;
    }
};

409. 最长回文串

给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。

在构造过程中，请注意 区分大小写 。比如 “Aa” 不能当做一个回文字符串。

示例 1:

输入:s = "abccccdd"
输出:7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。

示例 2:

输入:s = "a"
输入:1

示例 3：

输入:s = "aaaaaccc"
输入:7

提示:

  • 1 <= s.length <= 2000
  • s 只由小写 和/或 大写英文字母组成
class Solution:
    def longestPalindrome(self, s: str) -> int:
        dict = {}
        for c in s:
            dict[c] = dict.get(c, 0) + 1

        result = 0
        for value in dict.values():
            if value % 2 == 1:
                value -= 1
            result += value

        if len(s) == result:
            return result
        else:
            return result + 1      

class Solution {
public:
    int longestPalindrome(string s) {
        int result = 0;
        unordered_map<char, int> map;
        for(char c : s){
            map[c]++;
        }

        for(auto item : map){
            int value = item.second;
            if(value % 2 == 1){
                value -= 1;
            }
            result += value;
        }

        if(s.size() == result){
            return result;
        }else{
            return result + 1;
        }

    }
};

560. 和为K的子数组

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。

说明 :

  • 数组的长度为 [1, 20,000]。
  • 数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

具体算法：

  • 维护一个 hashmap，hashmap 的 key 为累加值 acc，value 为累加值 acc 出现的次数。
  • 迭代数组，然后不断更新 acc 和 hashmap，如果 acc 等于 k，那么很明显应该+1. 如果 hashmap[acc - k] 存在，我们就把它加到结果中去即可。

画了一个图来演示 nums = [1,2,3,3,0,3,4,2], k = 6 的情况。
在这里插入图片描述
如图，当访问到 nums[3]的时候，hashmap 如图所示，这个时候 count 为 2.
其中之一是[1,2,3],这个好理解。还有一个是[3,3].

这个[3,3]正是我们通过 hashmap[acc - k]即 hashmap[9 - 6]得到的。

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        '''
            前缀和；
                一次遍历；
                字典存储前缀和的值；
                当前前缀和减去K，则为之前的前缀和，查看是否字典存在；
                如果有则结果加1.
        '''

        # dict 存储某“前缀和”出现的次数
        # 如果某前缀不在此字典中，那么它对应的次数为0
        
        dict = {0: 1}  # 先给定一个初始值，代表前缀和为0的出现了一次
        total = 0  # 记录到当前位置的前缀和
        result = 0

        for i in range(len(nums)):
            total += nums[i]  # 计算当前和【从索引0到索引i的所有元素的和】
            
            if total - k in dict:  # 如果前缀和减去目标值k所得到的值在字典中出现，即当前位置前缀和减去之前某一位的前缀和等于目标值
                result += dict[total - k]
            
            dict[total] = dict.get(total, 0) + 1
        
        return result

面试题 01.01. 判定字符是否唯一

实现一个算法，确定一个字符串 s 的所有字符是否全都不同。

示例 1：

输入: s = "leetcode"
输出: false

示例 2：

输入: s = "abc"
输出: true

限制：

  • 0 <= len(s) <= 100
  • s[i]仅包含小写字母
  • 如果你不使用额外的数据结构，会很加分。
class Solution {
public:
    bool isUnique(string astr) {
        unordered_map<char, int> map;
        for(auto c : astr){
            if(map.find(c) != map.end()){
                return false;
            }
            map[c] = 1;
        }
        return true;
    }
};

class Solution:
    def isUnique(self, astr: str) -> bool:
        dict = {}
        for c in astr:
            if dict.get(c) is not None:
                return False
            dict[c] = 1
        
        return True

面试题 01.02. 判定是否互为字符重排

给定两个由小写字母组成的字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。

示例 1：

输入: s1 = "abc", s2 = "bca"
输出: true

示例 2：

输入: s1 = "abc", s2 = "bad"
输出: false

说明：

  • 0 <= len(s1) <= 100
  • 0 <= len(s2) <= 100

方法一：排序

class Solution {
public:
    bool CheckPermutation(string s1, string s2) {
        sort(s1.begin(), s1.end());
        sort(s2.begin(), s2.end());   
        return s1 == s2;   
    }
};

class Solution:
    def CheckPermutation(self, s1: str, s2: str) -> bool:
        s1 = list(s1)
        s2 = list(s2)
        s1.sort()
        s2.sort()

        return s1 == s2

方法二：哈希表
在这里插入图片描述

class Solution {
public:
    bool CheckPermutation(string s1, string s2) {
        unordered_map<char, int> map;
        for(char c : s1){
            map[c]++;
        }
        for(char c : s2){
            map[c]--;
        }
        for(auto kv : map){
            if(kv.second != 0){
                return false;
            }
        }
        return true;
    }
};

class Solution {
public:
    bool CheckPermutation(string s1, string s2) {
        unordered_map<char, int> map;
        for(char c : s1){
            map[c]++;
        }
        for(char c : s2){
            map[c]--;
        }
        for(pair<char, int> kv : map){
            if(kv.second != 0){
                return false;
            }
        }
        return true;
    }
};

面试题 01.04. 回文排列

给定一个字符串，编写一个函数判定其是否为某个回文串的排列之一。

回文串是指正反两个方向都一样的单词或短语。排列是指字母的重新排列。

回文串不一定是字典当中的单词。

示例1：

输入："tactcoa"
输出：true（排列有"tacocat"、"atcocta"，等等）

class Solution {
public:
    bool canPermutePalindrome(string s) {
        int count = 0;
        unordered_map<char, int> map;
        for(char c : s){
            map[c]++;
        }
        for(auto kv : map){
            if(kv.second % 2 == 1){
                count++;
            }
        }

        if(count > 1){
            return false;
        }else{
            return true;
        }
    }
};

class Solution:
    def canPermutePalindrome(self, s: str) -> bool:
        dict = {}

        for c in s:
            dict[c] = dict.get(c, 0) + 1
        
        count = 0
        for val in dict.values():
            if val % 2 == 1:
                count += 1
        
        if count > 1:
            return False
        else:
            return True
u013250861
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
哈希表经典题目
qq_33253721的博客
06-08 3970
1.哈希表 哈希表（hash table），也可译为散列表。官方解释为：哈希表是根据关键码的值而进行直接访问的数据结构。 我们先不管这个官方解释到底啥意思，直观上看，数组就是一张散列表。 哈希表中的关键码就是数组的索引下标，我们可以直接通过下标来访问数组中的元素。 哈希表主要用于快速判断一个元素是否出现在集合中。只需要O(1)的时间复杂度就能做到。 2.哈希函数 将元素映射到哈希表上就涉及到了哈希函数。 比如要查询某个学生是否在一所学校中，需要将学生姓名映射为哈希表上的索引，通过查询索引下标快速判断该学生
leetcode卡-leetcode-python::dizzy:Python版LeetCode:snake:
07-06
leetcode-python Usage python3 -m unittest discover -s ./tests/leetcode -t ./tests/leetcode Contents LeetCode Array 题目 来源 实现 0001. 两数之和 0118. 杨辉三角 0026. 删除有序数组中的重复项 0027. 移除...
unordered_map＜int,int＞
最新发布
2201_75574188的博客
07-22 223
是 C++ 标准库中的一个容器，它属于关联容器（associative container）类别。这个容器存储元素，其中每个元素都是一个键值对（key-value pair）。这个标准库基于哈希，可以解决。
871. 约数之和(乘法原理&&unordered_map＜int,int＞）
qq_45377553的博客
12-27 179
871. 约数之和 题意： 给你n个数相乘，求它的约数之和。 先 质因数分解，之后用乘法原理。 AC # include <bits/stdc++.h> using namespace std; int main(){ unordered_map<int,int> ma; int tt, n; cin>>tt; while(tt--){ cin>>n; for(int i = 2; i <=
C++ unordered_map用法
量子孤岛
04-28 5195
基本操作 引用头文件(C++11)：#include <unordered_map> 定义：unordered_map<int,int>、unordered_map<string, double>… 插入：例如将(“ABC” -> 5.45) 插入unordered_map<string, double> hash中，hash[“ABC”]=5...
【C++进阶】第二十二篇——unordered_map和unordered_set（容器接口介绍和使用+底层代码实现）
weixin_58450087的博客
03-12 1937
⭐️上一篇博客和大家介绍了关于哈希表和哈希桶的内容，今天就要用开散列的哈希表来实现今天要介绍的两个容器——unordered——map和unordered_set。 ⭐️博客代码已上传至gitee：https://gitee.com/byte-binxin/cpp-class-code 目录 ...
leetcode答案-LeetCode-Python:LeetCode-Python
06-30
【LeetCode-Python: LeetCode-Python 知识点详解】 LeetCode 是一个知名的在线编程挑战平台，专注于提升程序员的算法和数据结构技能。它包含了大量面试常考问题，覆盖了从入门到高级的各种难度。Python 作为一种...
leetcode双人赛-leetcode-python:leetcode-python
06-30
leetcode双人赛Leetcode Python 挑战 直到 2019-08-05 22:50:03，我已经解决了7 / 1072问题，而169仍然被锁定。 完成统计： Python：7 笔记： :locked: 意味着你需要从 LeetCode 购买一本书 力扣解决方案表 ID 标题 ...
leetcode答案-LeetCode--HashTable:LeetCode--哈希表
06-30
在"LeetCode--HashTable-master"这个项目中，可能包含了多种哈希表相关的LeetCode题解，涵盖了各种哈希表的应用场景，如查找、计数、去重、最短路径等问题。通过深入理解和实践这些题解，可以更好地掌握哈希表的使用...
Leetcode扑克-Leetcode-with-python:leetcode的python解决方案
06-30
Leetcode-with-python python solution for leetcode 数组 [283] 移动零 双指针 [345] 反转字符串中的元音字母 图 [785] 判断二分图 [207] 课程表 [886] 可能的二分法 [133] 克隆图 [684] 冗余连接 动态规划 [62] ...
std::unordered_map＜int, int＞ count；解析
2303_79299383的博客
12-02 1047
是一个哈希表实现，它允许你在平均常数时间内进行插入、删除和查找操作。是一个哈希表实现，它允许你在平均常数时间内进行插入、删除和查找操作。是C++标准库中的一个关联容器，用于存储键值对。在这个例子中，键和值都是整数类型。是C++标准库中的一个关联容器，用于存储键值对。在这个例子中，键和值都是整数类型。可以用来计算整数出现的次数。你可以使用这个变量来存储、检索、修改和删除键值对。你可以使用这个变量来存储、检索、修改和删除键值对。来找出只出现一次的数字，并计算它们的和。来找出只出现一次的数字，并计算它们的和。
【C++】： unordered_map的使用
元清的博客
11-30 1614
unordered_map中的的元素是键值对unordered_map中的key是唯一的，并且不能修改unordered_map遍历是一个无需的数列unordered_map的底层为哈希结构支持[ ]操作符，operator[ ]中实际进行插入查找。
C++ | unordered_map与unordered_set的用法指南
Nice_W的博客
07-30 2161
unordered_map与unordered_set是C++11推出的关联式容器，他们的作用与我们前面学习的map与set差不多一样，唯一不同的是这两个容器相比于map/set数据是无序的；我们从名字也可以看出来，具体上，实际上底层map/set是用的红黑树，而unordered_map/unordered_set是使用哈希来实现的；unordered_set也是一种关联式容器，作用主要与我们前面学过的set相同，我们首先看这个类的声明；具体如下；
C++中unordered_map/map
YMWM_的博客
08-23 143
基本介绍 键值对 key value 方法 unordered_map<int, int> h; h.find(key) == h.end() 如果成立，有这个元素 如果不成立，没有这个元素 h.erase(key) //删除这个键值对 for(auto [key, value] : h)//遍历 for(auto it = h.begin(); it != h.end(); it++)//遍历 cout << *it->first << ' ' &lt
算法题解：unordered_map基本操作与前缀和思想
weixin_74864740的博客
10-27 116
首先要求编译器支持C++11;
C++ 关联式容器之unordered_map
爱上小公举
02-23 3038
说到关联式容器, 需要区分是序列式容器, 例如vector, list, deque等都是序列式容器, 序列式其特点都体现在 "序列"上 .序列式容器中存储元素是线性排布的, 在进行查找搜索时效率较低. 序列式容器并不会对插入元素进行任何方式的重新排序, 插入在哪个位置就在哪个位置 .关联式容器, 特点也体现在 "关联"上, 关联式容器通过键值对(包括key和value), 将存储的每一个数据value与一个键值key一一对应起来, 只需要通过键值key就可以读写元素, 在查找搜索时效率高. 关联式容器
【LeetCode】706. Design HashMap（C++）
Ethan95的博客
11-06 865
地址：https://leetcode.com/problems/design-hashmap/ 描述： Design a HashMap without using any built-in hash table libraries. To be specific, your design should include these functions: put(key, value) : In...
【leetcode 设计题 C++】706. Design HashMap
izhxxx的博客
03-14 141
706. Design HashMap class MyHashMap { public: /** Initialize your data structure here. */ const int BASE = 1009; vector<list<pair<int, int> > > data; int getHashCode(int key) { return key % 1009; } MyHash
463. Island Perimeter(Leetcode每日一题-2020.10.30)
Bryan要加油
11-01 211
Problem You are given row x col grid representing a map where grid[i][j] = 1 represents land and grid[i][j] = 0 represents water. Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is ex
LeetCode 101道题详解：C++刷题指南
作者高畅在2018年为了准备实习秋招，自学并整理了大量的LeetCode题目，但发现缺少系统的归纳与详解。经过一年的努力，他在2019年将这些题目精选出101道，以简洁形式编撰成书，旨在帮助读者快速掌握算法和数据结构的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值