5哈希表-set/数组

已于 2023-03-17 13:59:51 修改
阅读量1k 收藏
点赞数
分类专栏： 算法复习 力扣 文章标签： 算法 数据结构
于 2022-03-31 23:08:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sueong/article/details/123883388
版权

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示在这里插入图片描述
参考：https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E5%93%88%E5%B8%8C%E5%87%BD%E6%95%B0

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram” 输出: true
示例 2:

输入: s = “rat”, t = “car” 输出: false

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        count = collections.Counter()
        for x in s:
            count[x] +=1
        
        for x in t:
            count[x] -=1
        
        # 如果count有数量不为0 说明s和t中有多余的元素
        for x in count.values():
            if x != 0:
                return False
        return True

'''
s = "rat", t = "car"
sss Counter({'r': 1, 'a': 1, 't': 1})
ttt Counter({'t': 1, 'r': 0, 'a': 0, 'c': -1})
'''
    

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        # 只包含小写字母 开个26位的数组
        count1 = [0]*26
        count2 = [0]*26
        for x in s:
            count1[ord(x)-ord("a")]+=1
        
        for x in t:
            count2[ord(x)-ord("a")]+=1
        
        return count1 == count2

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

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

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4] 解释：[4,9] 也是可通过的

在这里插入图片描述

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        res=[]
        #去重 
        nums1=set(nums1)
        nums2=set(nums2)
        # 比较nums1 nums2
        for x in nums1:
            if x in nums2:
                res.append(x)
        return res

利用python求交集

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        s1=set(nums1)
        s2=set(nums2)
        return list(s1&s2)

利用Counter

from collections import Counter


class Solution:
    def intersect(self, nums1, nums2):
        print(list(Counter(nums1).elements()))
        print(Counter(nums1))
        print(Counter(nums2))
        print((Counter(nums1)&Counter(nums2)))
        print(list((Counter(nums1) & Counter(nums2)).elements()))
        return sorted((Counter(nums1)&Counter(nums2)).elements())

ss=Solution()
# elements() 按照counter的计数，重复返回元素
'''

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
'''
# list直接按照Counter中key的顺序生成
# sort将element某个key的value从小到大排序
nums1 = [2,2,9,5,4]
nums2 = [9,4,9,8,4]
print(ss.intersect(nums1, nums2))
'''
[2, 9, 5, 4]
Counter({2: 1, 9: 1, 5: 1, 4: 1})
Counter({9: 2, 4: 2, 8: 1})
Counter({9: 1, 4: 1})
[9, 4]
[4, 9]

'''

首先排序俩个数组 然后分别设置俩个指针i和j指向俩数组的开头 如果i和j指向数组元素不相等 比较他们的大小
小的元素的指针向前移一位 如果相等的话就存进ans中

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
      sort(nums1.begin(),nums1.end());
    sort(nums2.begin(),nums2.end());
vector<int>ans;
int i=0,j=0;
while(i<nums1.size()&&j<nums2.size())
{
    if(nums1[i]>nums2[j]) j++;
    else if(nums1[i]<nums2[j]) i++;
    else if(nums1[i]==nums2[j]){
     ans.push_back(nums[i]);
       j++;i++;
    }
}
      
   return ans;
 }
};

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

在这里插入图片描述

class Solution:
    def isHappy(self, n: int) -> bool:
        def getsum(num):
            s = 0
            while num:
                s += (num%10)**2
                num = num//10
            return s
        
        record=set()
        while True:
            n =getsum(n)
            if n == 1:
                return True
            
            # 中间结果重复 说明循环过了 返回False 否则添加到record中
            if n in record:
                return False
            else:
                record.add(n)

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入：ransomNote = “a”, magazine = “b” 输出：false 示例 2：

输入：ransomNote = “aa”, magazine = “ab” 输出：false 示例 3：

输入：ransomNote = “aa”, magazine = “aab” 输出：true

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        '''
       利用Counter类统计各字符个数：
        - 如果前者出现的某字符后者没有
        - 或者前者出现的某字符个数大于后者该字符出现的个数
        则返回False
        '''
        c1 = Counter(ransomNote)
        c2 = Counter(magazine)
        for i in c1:
            if i not in c2 or c1[i]>c2[i]:
                return False
        return True

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        if len(ransomNote) > len(magazine):
            return False
        c1 = Counter(ransomNote)
        c2 = Counter(magazine)
        # 如果c1比c2有多的部分 则说明c2不能完全覆盖c1 此时c不空 所以False
        # 如果c2可以完全覆盖c1 比如aa和bbaaa 则c=c1-c2为空 Counter()
        c = c1 - c2
        return not Counter(ransomNote) - Counter(magazine)

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        #只有小写字母
        count1 = [0]*26
        count2 = [0]*26
        if len(ransomNote)>len(magazine):
            return False
        # count2中的每个位置的数都要大于等于count1中每个位置的数
        for x in ransomNote:
            count1[ord(x) - ord("a")] +=1
        
        for x in magazine:
            count2[ord(x) - ord("a")]+=1
        print(count1)
        print(count2)
        
        #遍历如果出现z同一位置的个数2-1小于0，说明不能组成，返回错误
        for i in range(0,26):
            print(count2[i] - count1[i])
            if count2[i] - count1[i] <0:
                return False
        return True

49. 字母异位词分组

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

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

示例 1:

输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”] 输出:
[[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]
示例 2:

输入: strs = [“”] 输出: [[“”]]
示例 3:

输入: strs = [“a”] 输出: [[“a”]]

法一：排序，利用defaultdict(list)

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        map = collections.defaultdict(list) # 指定没有key时 返回的是list 即[], {key:[]}
        for s in strs:
            # 如果相同字母次数的话则出现的 则sort后结果相同 如 aett和ttae ['a', 'e', 't', 't']
            key = sorted(s)
            key = ''.join(sorted(s))
            map[key].append(s)
        return list(map.values())

 class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        map = {}  
        for s in strs:
            # 如果相同字母次数的话则出现的 则sort后结果相同 如 aett和ttae ['a', 'e', 't', 't']
            key = ''.join(sorted(s))
            # 如果key不在字典 赋值
            if key not in map:
                map[key] = [s]
            
            # key在字典 
            else:
                map[key].append(s)

        return list (map.values())

法二：计数
比如将 [b,a,a,a,b,c] 编码成 a3b2c1，使用编码后的字符串作为 HashMap 的 Key 进行聚合。或出现的字母数字来作为key

class Solution:
    def groupAnagrams(self, str):
        mp = collections.defaultdict(list)

        # 如果是异位数 counts出现位置的次数相同 将count作为key
        for st in strs:
            counts = [0] * 26
            for ch in st:
                counts[ord(ch) - ord("a")] += 1
            # 需要将 list 转换成 tuple 才能进行哈希
            print(st, counts, mp)
            mp[tuple(counts)].append(st)

        return list(mp.values())


'''
eat [1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] defaultdict(<class 'list'>, {})
tea [1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] defaultdict(<class 'list'>, {(1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['eat']})
tan [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] defaultdict(<class 'list'>, {(1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['eat', 'tea']})
ate [1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] defaultdict(<class 'list'>, {(1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['eat', 'tea'], (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['tan']})
nat [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] defaultdict(<class 'list'>, {(1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['eat', 'tea', 'ate'], (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['tan']})
bat [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] defaultdict(<class 'list'>, {(1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['eat', 'tea', 'ate'], (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0): ['tan', 'nat']})
[['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

'''

438. 找到字符串中所有字母异位词

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 1:

输入: s = “cbaebabacd”, p = “abc” 输出: [0,6] 解释: 起始索引等于 0 的子串是 “cba”, 它是
“abc” 的异位词。 起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。
示例 2:

输入: s = “abab”, p = “ab” 输出: [0,1,2] 解释: 起始索引等于 0 的子串是 “ab”, 它是 “ab” 的异位词。 起始索引等于 1 的子串是 “ba”, 它是 “ab” 的异位词。 起始索引等于 2 的子串是 “ab”, 它是 "ab"的异位词。

  • 因为字符串中的字符全是小写字母，可以用长度为26的数组记录字母出现的次数
  • 设n = len(s), m = len§。记录p字符串的字母频次p_cnt，和s字符串前m个字母频次s_cnt
  • 若p_cnt和s_cnt相等，则找到第一个异位词索引 0
  • 继续遍历s字符串索引为[m, n)的字母，在s_cnt中每次增加一个新字母，去除一个旧字母
  • 判断p_cnt和s_cnt是否相等，相等则在返回值res中新增异位词索引 i - m + 1

作者：edelweisskoko
链接：https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/solution/438-zhao-dao-zi-fu-chuan-zhong-suo-you-z-nx6b/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution(object):
    def findAnagrams(self, s, p):
        """
        :type s: str
        :type p: str
        :rtype: List[int]
        """
        # 滑动窗口+数组
        n = len(s)
        m = len(p)
        if m>n:
            return []
        res = []
        s_cnt = [0]*26
        p_cnt = [0]*26

        for i in range(m):
            p_cnt[ord(p[i])-ord('a')]+=1
            s_cnt[ord(s[i])-ord('a')]+=1
        if s_cnt ==p_cnt:
            res.append(0)
        
        for i in range(m,n):
            #始终保持窗口长度为m
            # 增加一个新字母的个数 去掉一个旧字母的个数（去掉0,1,2...）
            s_cnt[ord(s[i])-ord('a')]+=1
            s_cnt[ord(s[i-m])-ord('a')]-=1
            if s_cnt == p_cnt:
                res.append(i+1-m)#添加的是起始位置start i-start+1=len(p) 所以start=i+1-m
        return res

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        #小写字母 长度26的数组 滑动窗口判断是否符合条件 窗口长度为3
        countP = [0]*26
        countS = [0]*26
        for x in p:
            countP[ord(x) - ord("a")] +=1

        l = 0
        res = []
        for r,x in enumerate(s):
            countS[ord(x)-ord("a")]+=1
            #左滑 缩小窗口
            while r - l + 1 > len(p):
                countS[ord(s[l]) - ord("a")] -=1
                l+=1
            #比较，然后更新结果
            if countS == countP:
                res.append(r-len(p)+1)
        return res

总结

在349. 两个数组的交集 (opens new window)需要用set。这道题目没有限制数值的大小，就无法使用数组来做哈希表了。

本题和242.有效的字母异位词 (opens new window)很像，242.有效的字母异位词 (opens new window)是求 字符串a 和 字符串b 是否可以相互组成，在383.赎金信 (opens new window)中是求字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a。要求只有小写字母，暗示用数组

sueong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现哈希表。
TPON的博客
11-17 6388
C++模拟实现哈希表
哈希表set,map
weixin_45601578的博客
02-05 208
哈希表基础要点
数组，List，Set相互转化
热门推荐
【程序员不弃】的博客
06-03 27万+
转载：https://blog.csdn.net/my_precious/article/details/530102321.数组转化为List：String[] strArray= new String[]{"Tom", "Bob", "Jane"};List strList= Arrays.asList(strArray);2.数组转SetString[] strArray= new Stri...
HashSet详解
weixin_52385232的博客
04-17 1万+
HashSet详解
数据结构之哈希表
m0_60529319的博客
10-21 158
哈希表 - 散列表，它是基于快速存取的角度设计的，也是一种典型的“空间换时间”的做法。
算法（42）-数组等值切割-前缀累加和-哈希表Map-set版-C++
01-07
题目：给定正整数，返回该数组能不能分成4... set和map两种哈希表类型。其实没啥本质差别。 1.unordered_set版   bool canSplits_set(vci arr) { if (arr.size() < 7) { return false; } unordered_set m
【Java】基础25：List、Set以及哈希表
12-20
昨天学习了几种简单数据结构，为何要了解数据结构？一方面的原因是因为集合的底层就是与其...HashSet的底层数据结构：哈希表。 前天学习了Collection集合，其继承体系图如下： 原创文章 25获赞 4访问量 617 关注
java 集合(list-queue-set)学习
最新发布
01-25
HashSet是最基础的Set实现，基于哈希表，提供快速的插入和查找操作，但不保证元素顺序。LinkedHashSet则在HashSet的基础上添加了元素的插入顺序，它维护了一个链表来记录元素的插入顺序。TreeSet实现了SortedSet接口...
Java集合类List-Set-Map的区别和联系.doc
06-25
HashMap 是一个基于哈希表的集合类，HashTable 是一个线程安全的基于哈希表的集合类，TreeMap 是一个基于树形结构的集合类。 三、Collections Collections 是 Java 中提供的一个工具类，提供了对集合类的操作方法...
c:set的用法
奔跑的蜗牛
09-03 1万+
STL系列之六 set与hash_set
MoreWindows Blog
12-01 4万+
STL系列之六 set与hash_setset和hash_set是STL中比较重要的容器，有必要对其进行深入了解。在STL中，set是以红黑树（RB-tree）作为底层数据结构的，hash_set是以Hash table（哈希表）作为底层数据结构的。set可以在时间复杂度为O(logN)情况下插入、删除和查找数据。hash_set操作的时间复杂度则比较复杂，这取决于哈希函数和哈希表的负载情况。下面
哈希表数组
THE_GREATEST的博客
05-09 1607
滑动窗口法 一、题源： 242. 有效的字母异位词 问题描述 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。 注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。 二、 思路： 1、映射 用 unordered_map 可以很方便的实现出现的字母及出现次数的计算。 参考代码如下 class Solution { public: bool isAnagram(string s, string t) { unor
JAVA集合Set之HashSet详解
zhaojie181711的博客
05-28 17万+
HashSet这个类实现了Set集合，实际为一个HashMap的实例。并且HashSet提供了三个构造函数
c:数组(3)
BNR32的博客
05-11 224
1. 返回值含义 返回值有时存在两种情况：合法值和非法值。 如果有非法值的情况，通常使用一些特定的值指代特殊情况。例如：数组下标只能是0和正数。我们实现数组查找元素下标时，存在找不到元素的情况，这时，使用-1可以作为这种情况的返回值。 返回值的含义以及值是人为定义的 2. 二维数组指针用法 一维数组指针用法 No. 操作 下标 指针 1 第i个元素值 arr[i] *(ar...
JSTL之<c:set>的各种用法
hello__word__的博客
01-26 2万+
<c:set>标签用于设置变量值和对象属性
set数组的创建和应用
li840793179的博客
05-08 1256
//声明一个set对象 lets= newSet(); letpizza= newSet(['one', 'two', 'three', 'four', 'five', 'six']) //console.log(pizza) //显示元素个数 size console.log(pizza.size)//6 //添加新元素 add() pizza.add('seve...
Python 哈希表set()的用法
m0_51753657的博客
11-25 1338
nodes=set() 创建一个哈希表nodes存放链表节点 nodes.add(pHead) 将pHead节点加入nodes哈希表
哈希表 python set(
01-18
在Python中，可以使用set来实现哈希表的功能。set是一种无序且不重复的集合，可以用来存储唯一的元素。 下面是一个使用set实现哈希表的例子： ```python class Solution(object): def intersection(self, nums1, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值