leetcode4、hot100——哈希表[1、49、128]

龙妞

已于 2023-11-14 14:40:20 修改

阅读量109

点赞数

分类专栏： leetcode hot100 python版数据结构文章标签：散列表哈希算法算法

于 2023-09-19 15:41:00 首次发布

本文链接：https://blog.csdn.net/qq_43573570/article/details/133031930

版权

python版数据结构同时被 3 个专栏收录

14 篇文章 0 订阅

订阅专栏

leetcode

7 篇文章 0 订阅

订阅专栏

hot100

4 篇文章 0 订阅

订阅专栏

python 内置函数hash(object)

python 内置函数hash(object)
- object必须为不可变对象
- hash值是一个整数，用来比较对象的快速等值性
- 相等的对象具有相同的哈希值，但相同哈希值的对象不一定相等（比如字母异位词）
1、两数之和
- 题目链接
- 题目描述
  - 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。
  - 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
  - 你可以按任意顺序返回答案。
- 思路1：暴力枚举
  - 遍历数组元素
    - 找target-x，遍历，再还未遍历过的数组元素里找，O(N)
  - 时间复杂度：O(N^2)
  - 空间复杂度：O(1)
- 思路2：哈希表
  - 创建一个空的哈希表，用来存储元素信息，哈希表元素为（key, value）=(数组元素，下标)
  - 遍历数组元素x
    - 找target-x，用字典/哈希表找，再遍历过的元素里找，O(1)
  - 时间复杂度：O(N)
  - 空间复杂度：O(N)
- python实现
- ```
def twoSum(nums, target):
    """
    :type nums: List[int]
    :type target: int
    :rtype: List[int]
    """
    n = len(nums)
    for i in range(n):
        for j in range(i+1, n):
            if nums[j] == target-nums[i]:
                return i, j


def twoSum2(nums, target):
    """
    :type nums: List[int]
    :type target: int
    :rtype: List[int]
    """
    hashtable = {}
    n = len(nums)
    for i in range(n):
        y = target-nums[i]
        if hashtable.get(y, -1) != -1:
            return i, hashtable[y]
        hashtable[nums[i]] = i

print(twoSum2(nums =[2,7,11,15], target=9))
```

49、字母异位词分组

题目链接
题目描述
- 给你一个字符串数组，请你将字母异位词组合在一起。可以按任意顺序返回结果列表。
- 字母异位词是由重新排列源单词的所有字母得到的一个新单词。
思路1：哈希表（报错）
- 关键点：所有字母异位词的哈希值一致！
  - 字母的ascii码是一样的，所以由字母构成的hash值一样
- 哈希表
  - key：单词的字母ascii码之和
  - value：字母异位词
  - 初始长度为字符串数组的长度
- 遍历字符串数组
  - 求字符串的哈希值
  - 判断单词的ascii码是否在哈希表中，O(1)
    - 如果存在，就将单词保存到对应的value中
    - 如果不存在，则新增
- 结果：报错
  - 原因是，非子母异位词的ascii值相加也有可能相等，比如duh和ill
思路2：哈希表
- 关键点：字母异位词的单词，构成单词的字母一致
- 哈希表
  - key：字母异位词标志
  - value：字母异位词列表
- 遍历字符串列表
  - 将单词s的字母进行排序重构成x，O(klogk)
    python sorted默认排序方式为快排
  - 在哈希表中查找是否存在x
    - 存在，则将单词s加入到对应的key中
    - 不存在，则新增单词s
- 时间复杂度：O(N*klogk)
  - n为字符串数组的长度
  - k为单词的长度
- 空间复杂度：O(Nk)
python实现

class Solution2(object):
    # 计算哈希码
    def __hash__(self, *args, **kwargs):
        s = args[0]
        asc = 0
        for c in s:
            asc += ord(c)
        return asc
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        hashTable = {}
        n = len(strs)
        for i in range(n):
            hashCode = self.__hash__(strs[i])
            value = hashTable.get(hashCode, None)
            if value is None:
                hashTable[hashCode] = [strs[i]]
            else:
                hashTable[hashCode].append(strs[i])
        return list(hashTable.values())


class Solution(object):
    # 不计算哈希码
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        hashTable = {}
        n = len(strs)
        for i in range(n):
            s = ''.join(sorted(strs[i]))
            value = hashTable.get(s, None)
            if value is None:
                hashTable[s] = [strs[i]]
            else:
                hashTable[s].append(strs[i])
        return list(hashTable.values())


s = Solution()
t = ["cab","tin","pew","duh","may","ill","buy","bar","max","doc"]
print(s.groupAnagrams(t))

128、最长连续序列

题目链接
题目描述
- 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
- 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
思路
- 哈希表
  - key：数组元素
  - value：元素索引
- 将数组nums转换成哈希表，O(N)
- 遍历数组nums
  - 查找nums[i]-1是否存在
    - 存在，则num不是左边界，不遍历查找右边界
    - 不存在，则num为左边界
      - 遍历查找右边界
    - 判断长度
- 时间复杂度：O(N)
- 空间复杂度：O(N)
python实现

def longestConsecutive(nums):
    """
    :type nums: List[int]
    :rtype: int
    时间复杂度为:O(N^3)
    """
    n = len(nums)
    length = 0
    for i in range(n):  # O(N)
        # 遍历查找右边界：以num为起点，判断num+1, num+2, ....是否在nums中
        j = 1  # j代表连续数组的长度
        num = nums[i]
        while num+j in nums:  # in的时间复杂度为：O(N)，while循环的最坏时间复杂度为O(N)
            j += 1
        length = max(length, j)
    return length


def longestConsecutive2(nums):
    """
    :type nums: List[int]
    :rtype: int
    优化查找，时间复杂度变为O(N^2)
    """
    n = len(nums)
    length = 0
    # 为nums创建哈希表，key为num，value为num索引
    hashTable = {}
    for i, x in enumerate(nums):
        hashTable[x] = i

    for i in range(n):  # O(N)
        # 遍历查找右边界：以num为起点，判断num+1, num+2, ....是否在nums中
        j = 1  # j代表连续数组的长度
        num = nums[i]
        while hashTable.get(num+j, None):  # 查找的时间复杂度为：O(1)，while循环的最坏时间复杂度为O(N)
            j += 1
        length = max(length, j)
    return length


def longestConsecutive3(nums):
    """
    :type nums: List[int]
    :rtype: int
    优化查找+优化左边界的查找：每个元素只会被遍历一次，时间复杂度变为O(N)
    """
    n = len(nums)
    length = 0
    # 为nums创建哈希表，key为num，value为num索引
    hashTable = {}
    for i, x in enumerate(nums):
        hashTable[x] = i

    for i in range(n):  # O(N)
        num = nums[i]
        # 无需针对每个num去判断num+1, num+2，，，是否在数组中
        # 如果num-1在数组中，说明num不为左边界值，无需遍历
        if hashTable.get(num-1, None):
            continue
        # 当num-1不在数组中时，说明num为左边界值，此时才遍历num的num+1,....
        # 遍历查找num右边界：以num为起点，判断num+1, num+2, ....是否在nums中
        j = 1  # j代表连续数组的长度
        while hashTable.get(num+j, None) is not None:  # 查找的时间复杂度为：O(1)，while循环的最坏时间复杂度为O(N)
            j += 1
        length = max(length, j)
    return length


def longestConsecutive4(nums):
    """
    :type nums: List[int]
    :rtype: int
    优化查找+优化左边界+优化右边界查找：时间复杂度变为O(N)
    """
    n = len(nums)
    length = 0
    # 为nums创建哈希表，key为num，value为num最远能到达的右边界,初始为自己
    hashTable = {}
    for x in nums:
        hashTable[x] = x

    for i in range(n):  # O(N)
        num = nums[i]
        # 无需针对每个num去判断num+1, num+2，，，是否在数组中
        # 如果num-1在数组中，说明num不为左边界值，无需遍历
        if hashTable.get(num-1, None):
            continue
        # 当num-1不在数组中时，说明num为左边界值，此时才遍历num的num+1,....
        right = hashTable[num]  # 初始右边界
        # 遍历得到num右边界
        while hashTable.get(right+1, None):  # 查找的时间复杂度为：O(1)，while循环的最坏时间复杂度为O(N)
            right = hashTable[right+1]
        hashTable[num] = right
        length = max(length, right - num + 1)
    return length


t = [100,4,200,1,3,2]
t2 = [0,3,7,2,5,8,4,6,0,1]
t3 = [0,-1]
print(longestConsecutive(t))
print(longestConsecutive(t2))
print(longestConsecutive2(t))
print(longestConsecutive2(t2))
print(longestConsecutive3(t))
print(longestConsecutive3(t2))
print(longestConsecutive3(t3))