LeetCode 分类练习 Task03：查找1

基本数据结构：

第一类： 查找有无–set
元素’a’是否存在，通常用set：集合
set只存储键，而不需要对应其相应的值。
set中的键不允许重复
第二类： 查找对应关系(键值对应)–dict
元素’a’出现了几次：dict–>字典
dict中的键不允许重复
第三类： 改变映射关系–map
通过将原有序列的关系映射统一表示为其他

练习

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        nums1 = set(nums1)
        return set([i for i in nums2 if i in nums1])

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:  
        from collections import Counter
        nums1_dict = Counter(nums1)
        res = []
        for num in nums2:
            if nums1_dict[num] > 0:
            # 说明找到了一个元素即在num1也在nums2
            res.append(num)
            nums1_dict[num] -= 1
        return res 

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import Counter
        s = Counter(s)
        t = Counter(t)
        if s == t:
            return True
        else:
            return False

class Solution:
    def isHappy(self, n: int) -> bool:
        already = set()
        while n != 1:
	    sum = 0	
	    while n > 0:
	 	# 取n的最后一位数
                tmp = n % 10   
 		sum += tmp ** 2
 		# 将n的最后一位截掉
		n //= 10
	    # 如果求的和在过程中出现过
 	    if sum in already:
 		return False
 	    else:
                already.add(sum)
   	    n = sum
 	return True

class Solution:	
    def wordPattern(self,pattern, str):
        str = str.split()
	return list(map(pattern.index,pattern)) == list(map(str.index,str))

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:	
	return list(map(s.index,s)) == list(map(t.index,t))

class Solution:
    def frequencySort(self, s: str) -> str:
	from collections import Counter
	s_dict = Counter(s)
 	# sorted返回的是列表元组
 	s = sorted(s_dict.items(), key=lambda item:item[1], reverse = True)
 	# 因为返回的是字符串
 	res = ''
 	for key, value in s:
   	    res += key * value 
 	return res

TIPS

1. 一般对多位数计算的套路是：

#循环从后向前取位数
while n >0 :
    #取最后一位： 
    tmp = n % 10
    #再截掉最后一位：
    n = n // 10

2. 通过map将字典映射为index的list：

map(pattern.index, pattern)

map是通过hash存储的，不能直接进行比较，需要转换为list比较list

3. 通过sorted的方法进行value排序，对字典排序后无法直接按照字典进行返回，返回的为列表元组 ：

# 对value值由大到小排序
s = sorted(s_dict.items(), key=lambda item:item[1], reverse = True)
# 对key由小到大排序
s = sorted(s_dict.items(), key=lambda item:item[0])