Leetcode题解-算法-哈希表（python版）

1、两数之和

1. 两数之和(Easy)

方法一：暴力搜索

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        n = len(nums)
        for i in range(n):
            for j in range(i+1, n):
                if nums[i] + nums[j] == target:
                    return [i, j]
        return [i, j]

时间复杂度：O(N²)
空间复杂度：O(1)

方法二：暴力搜索
将每个数值作为 key，下标作为 key 的 value 值，对于每一个数 nums[i]，寻找 key 值为 target - nums[i] 的元素是否存在，存在且是两个元素，就找到了答案。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target-num in hashtable:
                return [i, hashtable[target - num]]
            hashtable[num] = i
        return []

时间复杂度：O(n)
空间复杂度：O(n)

2、判断数组中是否有重复的数

217. 存在重复元素(Easy)

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        hashtable = dict()
        for i, num in enumerate(nums):
            if num in hashtable:
                return True
            hashtable[num] = i
        return False

时间复杂度：O(n)
空间复杂度：O(n)

3、最长和谐序列

594. 最长和谐子序列(Easy)

我们首先遍历一遍数组，得到每个数出现的次数。随后遍历哈希映射，设当前遍历到的键值对为 (x,value)，那么我们就查询 x+1 在哈希映射中对应的统计次数，就得到了 x 和 x+1 出现的次数，和谐子序列的长度等于 x 和 x + 1 出现的次数之和。

class Solution:
    def findLHS(self, nums: List[int]) -> int:
        res= 0
        hashtable = Counter(nums)

        for k, v in hashtable.items():
            if k+1 in hashtable:
                res = max(res, v + hashtable[k+1])
        return res

时间复杂度：O(n)
空间复杂度：O(n)

4、最长连续序列

128. 最长连续序列(Medium)

遍历数组。查看以当前元素为起点最长的连续数列的长度。

当前元素为x，若x-1也在数组中，则x不是序列的开始元素。否则当前连续序列必然以x开始，考虑以其为起点，不断尝试匹配 x+1, x+2,⋯ 是否存在，假设最长匹配到了 x+y，那么以 x 为起点的最长连续序列即为 x, x+1, x+2,⋯,x+y，其长度为 y+1，遍历更新答案即可。

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        nums_set = set(nums)
        longest_seq_res = 0

        for num in nums_set:
            if num - 1 not in  nums_set:
                cur_seq_len = 1
                cur_num = num
                while cur_num + 1 in nums_set:
                    cur_seq_len += 1
                    cur_num += 1
                longest_seq_res = max(longest_seq_res, cur_seq_len)
        return longest_seq_res

5、LRU

146. LRU 缓存(Medium)

解题思路：使用 hash 和双向链表，hash中 key 对应的 value 为指向链表的一个节点，双向链表中的元素为pair<int, int>，分别是 key 值和 value。

插入节点时，如果节点存在，就将该元素从链表中取出，放到链表的头部，并更新 hash 中 key 值对应的value。如果节点不存在，将新节点插到链表开头。如果达到了最大容量，将链表尾部的元素删除，并删除 hash 中的元素。

查找节点时，在 hash 中查找， 找不到，返回 -1，找到了，将该节点调整到链表头部。

在双向链表的实现中，使用一个伪头部和伪尾部标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。

class Node:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.pre = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = dict()
        self.head = Node()
        self.tail = Node()
        self.head.next = self.tail
        self.tail.pre = self.head
        self.capacity = capacity
        self.size = 0


    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.move_to_head(node)
        return node.value


    def put(self, key: int, value: int) -> None:
        if key not in self.cache:
            node = Node(key, value)
            self.cache[key] = node
            self.add_to_head(node)
            self.size += 1
            if self.size > self.capacity:
                need_delete_node = self.delete_tail()
                self.cache.pop(need_delete_node.key)
                self.size -= 1
        else:
            node = self.cache[key]
            node.value = value
            self.move_to_head(node)

    def add_to_head(self, node):
        node.pre = self.head
        node.next = self.head.next
        self.head.next.pre = node
        self.head.next = node

    def delete_node(self, node):
        node.pre.next = node.next
        node.next.pre = node.pre
        return node

    def move_to_head(self, node):
        node = self.delete_node(node)
        self.add_to_head(node)

    def delete_tail(self):
        node = self.tail.pre
        self.delete_node(node)
        return node
# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)