查找——查找表

查找——查找表

**

考虑的基本数据结构

第一类： 查找有无–set
元素’a’是否存在，通常用set：集合
set只存储键，而不需要对应其相应的值。
set中的键不允许重复

第二类： 查找对应关系(键值对应)–dict
元素’a’出现了几次：dict–>字典
dict中的键不允许重复

第三类： 改变映射关系–map
通过将原有序列的关系映射统一表示为其他

题目描述
给定两个数组nums,求两个数组的公共元素

设置其中一组数组为set1 ， 之后遍历另一组数组查看是否有元素存在于set1中， 如果有则返回一个公共set：

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

或者：

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

题目描述

给定两个数组nums,求两个数组的交集。

用dict数据结构来记录nums1：key为数字，value为数字出现次数。
遍历nums2中的元素在dict中查看key所对应value是否大于0， 如果大于0 则append一个key进入返回的数组中， 同时该key所对应value值 - 1。

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   

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

由于是两个相同字母且字母对应个数相同的两个字符串， 所以只需要将这两个字符串的字母作为key值，字母出现个数作为value值存入dict中，再判断两个dict是否完全相同即可。

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

题目描述
编写一个算法来判断一个数是不是“快乐数”。
一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。

示例:
输入: 19
输出: true
解释:
1² + 9² = 82
8² + 2² = 68
6² + 8² = 100
1² + 0² + 0² = 1

解题思路：
设置输出为n, 当输出不为1的时候持续循环，输出=每一次的输入的各个相位平方之和。记录每一次得出的和值在一个set中， 如果有发现有新的和值已经存在于该set中， 则结束循环，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

题目描述
给出一个模式(pattern)以及一个字符串，判断这个字符串是否符合模式。
示例1:
输入: pattern = “abba”,
str = “dog cat cat dog”
输出: true

示例 2:
输入:pattern = “abba”,
str = “dog cat cat fish”
输出: false

示例 3:
输入: pattern = “aaaa”, str = “dog cat cat dog”
输出: false

分析实现
抓住变与不变，笔者开始的思路是选择了dict的数据结构，比较count值和dict对应的keys的个数是否相同，但是这样无法判断顺序的关系，如测试用例：‘aba’,‘cat cat dog’。
那么如何能既考虑顺序，也考虑键值对应的关系呢？
抓住变与不变，变的是键，但是不变的是各个字典中，对应的相同index下的值，如dict1[index] = dict2[index]，那么我们可以创建两个新的字典，遍历index对两个新的字典赋值，并比较value。
还有一个思路比较巧妙，既然不同，那么可以考虑怎么让它们相同，将原来的dict通过map映射为相同的key，再比较相同key的dict是否相同。

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

题目描述
给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，
但字符可以映射自己本身。

示例 1:
输入: s = “egg”, t = “add”
输出: true

示例 2:
输入: s = “foo”, t = “bar”
输出: false

示例 3:
输入: s = “paper”, t = “title”
输出: true

跟上题思路一样：

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

题目描述
给定一个字符串，请将字符串里的字符按照出现的频率降序排列。
示例 1:
输入:
“tree”
输出:
“eert”

示例 2:
输入:
“cccaaa”
输出:
“cccaaa”

示例 3:
输入:
“Aabb”
输出:
“bbAa”

用dict来记录输入字符串， 字母为key，出现次数为value。对该dict里的value进行降序排序，输出排序完所对应的字母组合成一个string。

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