数据结构-哈希表与布隆过滤器

705. 设计哈希集合

import re 

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

class MyHashSet:

    def __init__(self):
        self.bucket = [None] * 1009 

    def get_hash(self, key: int):
        return key % 1009

    def add(self, key: int) -> None:
        head = self.bucket[self.get_hash(key)]
        if not head:
            self.bucket[self.get_hash(key)] = ListNode(key)
            return 
        while head:
            pre = head
            if head.val == key:
                return 
            head = head.next
        pre.next = ListNode(key)
        return 


    def remove(self, key: int) -> None:
        head = self.bucket[self.get_hash(key)]
        if not head:
            return
        elif head.val == key:
            self.bucket[self.get_hash(key)] = head.next
            return 
        while head.next:
            pre = head
            head = head.next
            if head.val == key:
                pre.next = head.next
                return
        return 

    def contains(self, key: int) -> bool:
        head = self.bucket[self.get_hash(key)]
        if not head:
            return False 
        while head:
            if head.val == key:
                return True
            head = head.next
        return False


# Your MyHashSet object will be instantiated and called as such:
# obj = MyHashSet()
# obj.add(key)
# obj.remove(key)
# param_3 = obj.contains(key)

706. 设计哈希映射

class MyHashMap:

    def __init__(self):
        self.bucket  = 1009
        self.table = [[] for _ in range(self.bucket)]

    def get_hash(self, key: int):
        return key % self.bucket

    def put(self, key: int, value: int) -> None:
        hashkey = self.get_hash(key)
        for item in self.table[hashkey]:
            if item[0] == key:
                item[1] = value
                return 
        self.table[hashkey].append([key, value])


    def get(self, key: int) -> int:
        hashkey = self.get_hash(key)
        for item in self.table[hashkey]:
            if item[0] == key:
                return item[1]
        return -1

    def remove(self, key: int) -> None:
        hashkey = self.get_hash(key)
        for i, item in enumerate(self.table[hashkey]):
            if item[0] == key:
                self.table[hashkey].pop(i)
                return



# Your MyHashMap object will be instantiated and called as such:
# obj = MyHashMap()
# obj.put(key,value)
# param_2 = obj.get(key)
# obj.remove(key)

535. TinyURL 的加密与解密

187. 重复的DNA序列

class Solution:
    def findRepeatedDnaSequences(self, s: str) -> List[str]:
        substr = dict()
        for i in range(0, len(s) - 9):
            key = s[i: i + 10]
            if key not in substr:
                substr[key] = 0
            substr[key] += 1
        ans = []
        for key in substr.keys():
            if substr[key] < 2: continue
            ans.append(key)
        return ans

318. 最大单词长度乘积

class Solution:
    def maxProduct(self, words: List[str]) -> int:
        max_num = 0
        # 字典的内部原理
        dic = {}
        for word in words:
            mask = 0
            for c in word:
                mask |= 1 << ord(c) - ord('a')
            dic[mask] = max(dic.get(mask, 0), len(word))
            for key,value in dic.items():
                if mask & key == 0:
                    max_num = max(max_num, len(word) * value)
        
        return max_num

面试题 16.25. LRU 缓存

class LinkNode:
    def __init__(self, key = 0, val = 0, prev= None, next = None):
        self.key = key
        self.val = val
        self.prev = prev
        self.next = next
    def remove_this(self):
        if self.prev: self.prev.next = self.next
        if self.next: self.next.prev = self.prev
        self.prev = None
        self.next = None

    def insert_prev(self, node):
        node.next = self
        node.prev = self.prev
        if self.prev: self.prev.next = node
        self.prev = node
class HashList:
    def __init__(self, capacity):
        self.capacity = capacity
        self.data = {}
        self.head = LinkNode()
        self.tail = LinkNode()
        self.head.next = self.tail
        self.tail.prev = self.head
    
    def put(self, key, val):
        if key in self.data:
            self.data[key].val = val
            self.data[key].remove_this()
        else:
            self.data[key] = LinkNode(key, val)
        self.tail.insert_prev(self.data[key])
        if len(self.data) > self.capacity:
            self.data.pop(self.head.next.key)
            self.head.next.remove_this()

    def get(self, key):
        if key not in self.data: return -1
        self.data[key].remove_this()
        self.tail.insert_prev(self.data[key])
        return self.data[key].val
class LRUCache:

    def __init__(self, capacity: int):
        self.h = HashList(capacity)

    def get(self, key: int) -> int:
        return self.h.get(key)

    def put(self, key: int, value: int) -> None:
        self.h.put(key, value)


# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

240. 搜索二维矩阵 II

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        i, j = 0, len(matrix[0]) - 1
        while i < len(matrix) and j >= 0:
            if matrix[i][j] == target: return True
            if matrix[i][j] < target: i += 1
            else: j -= 1
        return False

863. 二叉树中所有距离为 K 的结点

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def distanceK(self, root: TreeNode, target: TreeNode, k: int) -> List[int]:
            def dfs(root, k, c, ans):
                if k < 0: return 
                if not root: return 
                if c == k:
                    ans.append(root.val)
                    return 
                dfs(root.left, k, c + 1, ans)
                dfs(root.right, k, c + 1, ans)

            def get_help(root, k, target, ans):
                if not root: return False, k
                if root == target:
                    dfs(root, k, 0 ,ans)
                    return True, k 
                in_left, k1 = get_help(root.left, k, target, ans)
                if in_left:
                    k1 -= 1
                    if  k1 == 0: 
                        ans.append(root.val)
                        return True, k1 
                    dfs(root.right, k1 - 1, 0, ans)
                    return True, k1
                in_right, k1 = get_help(root.right, k, target, ans)
                if in_right:
                    k1 -= 1
                    if k1 == 0:
                        ans.append(root.val)
                        return True, k1
                    dfs(root.left, k1 - 1, 0, ans)
                    return True, k1
                return False, k1
            ans = []
            get_help(root,k, target, ans)
            return ans

979. 在二叉树中分配硬币

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def distributeCoins(self, root: Optional[TreeNode]) -> int:
        self.ans = 0
        def get_help(root):
            if not root: return 0, 0
            left_node, left_coin = get_help(root.left)
            right_node, right_coin = get_help(root.right)
            self.ans += abs(1 + left_node + right_node - root.val - left_coin - right_coin)
            return 1 + left_node + right_node, root.val + left_coin + right_coin
        get_help(root)
        return self.ans

430. 扁平化多级双向链表

"""
# Definition for a Node.
class Node:
    def __init__(self, val, prev, next, child):
        self.val = val
        self.prev = prev
        self.next = next
        self.child = child
"""

class Solution:
    def flatten(self, head: 'Node') -> 'Node':
        p = head
        while p:
            if p.child:
                q = p.next
                k = self.flatten(p.child)
                p.child = None 
                p.next = k
                k.prev = p
                while p.next: p = p.next
                p.next = q
                if q: q.prev = p
            p = p.next
        return head