棧隊列 hash表堆算法模板和相關題目

樣例1 :

MovingAverage m = new MovingAverage(3);
m.next(1) = 1 // 返回 1.00000
m.next(10) = (1 + 10) / 2 // 返回 5.50000
m.next(3) = (1 + 10 + 3) / 3 // 返回 4.66667
m.next(5) = (10 + 3 + 5) / 3 // 返回 6.00000

from collections import deque

class MovingAverage:
    """
    @param: size: An integer
    """
    def __init__(self, size):
        # do intialization if necessary
        self.q = deque()
        self.size = size
        self.sum = 0

    """
    @param: val: An integer
    @return:  
    """
    def next(self, val):
        # write your code here
        if len(self.q) == self.size:
            self.sum -= self.q.popleft()
        self.q.append(val)
        self.sum += val
        return self.sum/len(self.q)
        

# Your MovingAverage object will be instantiated and called as such:
# obj = MovingAverage(size)
# param = obj.next(val)

134. LRU緩存策略

樣例

樣例 1:

輸入：
LRUCache(2)
set(2, 1)
set(1, 1)
get(2)
set(4, 1)
get(1)
get(2)
輸出：[1,-1,1]
解釋：
cache上限為2，set(2,1)，set(1, 1)，get(2) 然后返回 1，set(4,1) 然后 delete (1,1)，因為 （1,1）最少使用，get(1) 然后返回 -1，get(2) 然后返回 1。

樣例 2:

輸入：
LRUCache(1)
set(2, 1)
get(2)
set(3, 2)
get(2)
get(3)
輸出：[1,-1,2]
解釋：
cache上限為 1，set(2,1)，get(2) 然后返回 1，set(3,2) 然后 delete (2,1)，get(2) 然后返回 -1，get(3) 然后返回 2。

from collections import deque

class LRUCache:
    """
    @param: capacity: An integer
    """
    def __init__(self, capacity):
        # do intialization if necessary
        self.cap = capacity
        self.q = deque()
        self.cache = dict()

       
    def move2tail(self, key):  
        self.q.remove(key)
        self.q.append(key)
        
            
    """
    @param: key: An integer
    @return: An integer
    """
    def get(self, key):
        # write your code here
        if key in self.cache:
            self.move2tail(key)
            return self.cache[key]
        else:
            return -1


    """
    @param: key: An integer
    @param: value: An integer
    @return: nothing
    """
    def set(self, key, value):
        # write your code here
        if key in self.cache:
            self.cache[key] = value
            self.move2tail(key)
        else:
            if len(self.q) == self.cap:
                del self.cache[self.q.popleft()]
            self.q.append(key)
            self.cache[key] = value

這個實現的時間復雜度有點高，更新的時候是O（n），使用hash+雙向鏈表是最優的思路，其中hash存儲的是鏈表的節點地址。還是有點繁瑣，代碼較多，一次性寫對比較難，我自己寫的：

class Node(object):
    def __init__(self, val=None, pre=None, next=None):
        self.val = val
        self.pre = pre
        self.next = next


class LinkList(object):
    def __init__(self):
        self.dummy = Node()
        self.tail = None
        self.size = 0

    def append(self, value):
        new_node = Node(value)
        if self.tail is None:
            self.tail = new_node
            self.dummy.next = new_node
            new_node.pre = self.dummy
        else:
            self.tail.next = new_node
            new_node.pre = self.tail
            self.tail = new_node
        self.size += 1
        return new_node

    def popleft(self):
        pop_node = self.dummy.next
        self.remove(pop_node)
        return pop_node

    def remove(self, node):
        if not node:
            return
        pre_node = node.pre
        next_node = node.next
        if pre_node:
            pre_node.next = next_node
        if next_node:
            next_node.pre = pre_node
        else:
            self.tail = pre_node
        self.size -= 1

    def __len__(self):
        return self.size


class LRUCache:
    """
    @param: capacity: An integer
    """

    def __init__(self, capacity):
        # do intialization if necessary
        self.cap = capacity
        self.q = LinkList()
        self.cache = dict()

    def move2tail(self, key, value=None):
        node = self.cache[key]
        assert node.val[0] == key
        self.q.remove(node)
        if value is None:
            value = node.val[1]
        new_node = self.q.append((key, value))
        self.cache[key] = new_node
        return new_node

    """
    @param: key: An integer
    @return: An integer
    """

    def get(self, key):
        # write your code here
        if key in self.cache:
            node = self.move2tail(key)
            return node.val[1]
        else:
            return -1

    """
    @param: key: An integer
    @param: value: An integer
    @return: nothing
    """

    def set(self, key, value):
        # write your code here
        if key in self.cache:
            self.move2tail(key, value)
        else:
            if len(self.q) == self.cap:
                node = self.q.popleft()
                del self.cache[node.val[0]]
            node = self.q.append((key, value))
            self.cache[key] = node

還有單鏈表的做法：

如下(單鏈表)：

class LinkedNode:
    
    def __init__(self, key=None, value=None, next=None):
        self.key = key
        self.value = value
        self.next = next

class LRUCache:

    # @param capacity, an integer
    def __init__(self, capacity):
        self.key_to_prev = {}
        self.dummy = LinkedNode()
        self.tail = self.dummy
        self.capacity = capacity
    
    def push_back(self, node):
        self.key_to_prev[node.key] = self.tail
        self.tail.next = node
        self.tail = node
    
    def pop_front(self):
        # 刪除頭部
        head = self.dummy.next
        del self.key_to_prev[head.key]
        self.dummy.next = head.next
        self.key_to_prev[head.next.key] = self.dummy
        
    # change "prev->node->next...->tail"
    # to "prev->next->...->tail->node"
    def kick(self, prev):    #將數據移動至尾部
        node = prev.next
        if node == self.tail:
            return
        
        # remove the current node from linked list
        prev.next = node.next
        # update the previous node in hash map
        self.key_to_prev[node.next.key] = prev
        node.next = None

        self.push_back(node)

    # @return an integer
    def get(self, key):		#獲取數據
        if key not in self.key_to_prev:
            return -1
        self.kick(self.key_to_prev[key])
        return self.key_to_prev[key].next.value

    # @param key, an integer
    # @param value, an integer
    # @return nothing
    def set(self, key, value):     #數據放入緩存
        if key in self.key_to_prev:	   
            self.kick(self.key_to_prev[key])
            self.key_to_prev[key].next.value = value
        	return
        
        self.push_back(LinkedNode(key, value))  #如果key不存在，則存入新節點
        if len(self.key_to_prev) > self.capacity:		#如果緩存超出上限
            self.pop_front()					#刪除頭部

960. 數據流中第一個獨特的數 II

樣例

例1:

輸入:
add(1)
add(2)
firstUnique()
add(1)
firstUnique()
輸出:
[1,2]

例2:

輸入:
add(1)
add(2)
add(3)
add(4)
add(5)
firstUnique()
add(1)
firstUnique()
add(2)
firstUnique()
add(3)
firstUnique()
add(4)
firstUnique()
add(5)
add(6)
firstUnique()
輸出:
[1,2,3,4,5,6]

657. Insert Delete GetRandom O(1)

樣例

// 初始化空集set
RandomizedSet randomSet = new RandomizedSet();

// 1插入set中。返回正確因為1被成功插入
randomSet.insert(1);

// 返回錯誤因為2不在set中
randomSet.remove(2);

// 2插入set中，返回正確，set現在有[1,2]。
randomSet.insert(2);

// getRandom 應該隨機的返回1或2。
randomSet.getRandom();

// 從set中移除1，返回正確。set現在有[2]。
randomSet.remove(1);

// 2已經在set中，返回錯誤。
randomSet.insert(2);

// 因為2是set中唯一的數字，所以getRandom總是返回2。
randomSet.getRandom();

使用數組來保存當前集合中的元素，同時用一個hashMap來保存數字與它在數組中下標的對應關系。

插入操作時：

若已存在此元素返回false
不存在時將新的元素插入數組最后一位，同時更新hashMap。

刪除操作時：

若不存在此元素返回false
存在時先根據hashMap得到要刪除數字的下標，再將數組的最后一個數放到需要刪除的數的位置上，刪除數組最后一位，同時更新hashMap。

獲取隨機數操作時：

根據數組的長度來獲取一個隨機的下標，再根據下標獲取元素。

from random import randint

class RandomizedSet:
    
    def __init__(self):
        # do intialization if necessary
        self.pos_map = {}
        self.elements = []
        self.size = 0

    """
    @param: val: a value to the set
    @return: true if the set did not already contain the specified element or false
    """
    def insert(self, val):
        # write your code here
        if val in self.pos_map:
            return True
        if len(self.elements) == self.size:
            self.elements.append(val)
        else:
            self.elements[self.size] = val
        self.pos_map[val] = self.size
        self.size += 1
        return False

    """
    @param: val: a value from the set
    @return: true if the set contained the specified element or false
    """
    def remove(self, val):
        # write your code here
        if val not in self.pos_map:
            return False
        pos = self.pos_map[val]
        del self.pos_map[val]
        last_element = self.elements[self.size-1]
        self.elements[pos] = last_element
        self.pos_map[last_element] = pos
        self.size -= 1
        return True
   

    """
    @return: Get a random element from the set
    """
    def getRandom(self):
        # write your code here
        return self.elements[randint(0, self.size-1)]

# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param = obj.insert(val)
# param = obj.remove(val)
# param = obj.getRandom()

當然，使用self.nums.pop()也可以，就不用再記錄size了。

如果是非重復元素，

954. Insert Delete GetRandom O(1) - 允許重復

樣例

樣例 1:

輸入:
insert(1)
insert(1)
insert(2)
getRandom()
remove(1)

// 初始化一個空的容器
RandomizedCollection collection = new RandomizedCollection();

// 把 1 插入到這容器中。如果這個容器不含 1 則返回 true 
collection.insert(1);

// 把 1 插入到這容器中。如果這個容器含 1 則返回 false, 此時容器中含有 [1,1]。
collection.insert(1);

// 把 1 插入到這容器中， 返回 true, 此時容器中含有 [1,1,2].
collection.insert(2);

// getRandom 應該有 2/3 的概率返回 1 ，1/3 的概率返回 2。
collection.getRandom();

// 從容器中刪去一個 1 ， 此時容器中含有 [1,2].
collection.remove(1);

// getRandom 應該可以同等概率的返回 1 和 2。
collection.getRandom();

樣例 2:

輸入:
insert(1)
insert(1)
getRandom()
remove(1)

注意事項

允許有重復元素

則：

基本算法是不變的，只不過需要一個辦法來處理重復的數。
這里的解決辦法是，用 HashMap 存儲 number to a list of indices in numbers array. 也就是說，把某個數在數組中出現的所有的位置用 List 的形式存儲下來
這樣子的話，刪除一個數的時候，就是從這個 list 里隨便拿走一個數（比如最后一個數）
但是還需要解決的問題是，原來的算法中，刪除一個數的時候，需要拿 number array 的最后個位置的數，來覆蓋掉被刪除的數。那這樣原本在最后一個位置的數，他在 HashMap 里的記錄就應該相應的變化。
但是，我們只能得到這個移動了的數是什么，而這個被移動過的數，可能出現在好多個位置上，去要從 HashMap 里得到的 indices 列表里，改掉那個 index=當前最后一個位置的下標。
所以這里的做法是，修改 number array，不只是存儲 Number，同時存儲，這個數在 HashMap 的 indices 列表中是第幾個數。這樣就能直接去改那個數的值了。否則還得 for 循環一次，就無法做到 O(1)

import random
import collections


class RandomizedCollection(object):

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.elements = []
        self.indexes = collections.defaultdict(set)
        

    def insert(self, val):
        """
        Inserts a value to the collection. Returns true if the collection did not already contain the specified element.
        :type val: int
        :rtype: bool
        """
        self.elements.append(val)
        ans = False
        if val in self.indexes:
            ans = True
        self.indexes[val].add(len(self.elements)-1)
        return ans

    """
    just choose one element in set data
    """
    def choose_one(self, set_data):
        for i in set_data:
            return i
    
    
    def remove(self, val):
        """
        Removes a value from the collection. Returns true if the collection contained the specified element.
        :type val: int
        :rtype: bool
        """
        if val in self.indexes and self.indexes[val]:
            last_pos = len(self.elements)-1
            last_element = self.elements[last_pos]
            assert last_pos in self.indexes[last_element]
            self.indexes[last_element].remove(last_pos)
            
            if val != last_element:
                pos = self.choose_one(self.indexes[val])
                self.indexes[last_element].add(pos)
                self.indexes[val].remove(pos)
                self.elements[pos] = last_element
            self.elements.pop()
            return True
        else:
            return False
        

    def getRandom(self):
        """
        Get a random element from the collection.
        :rtype: int
        """
        return self.elements[random.randint(0, len(self.elements)-1)]
        


# Your RandomizedCollection object will be instantiated and called as such:
# obj = RandomizedCollection()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

至少有一個子數組的和為 0

用前綴和某一段[l, r]的和為0，則其對應presum[l-1] = presum[r].
presum 為數組前綴和。只要保存每個前綴和，找是否有相同的前綴和即可。

class Solution:
    """
    @param nums: A list of integers
    @return: A list of integers includes the index of the first number and the index of the last number
    """
    def subarraySum(self, nums):
        prefix_hash = {0: -1}
        prefix_sum = 0
        for i, num in enumerate(nums):
            prefix_sum += num
            if prefix_sum in prefix_hash:
                return prefix_hash[prefix_sum]+1, i
            prefix_hash[prefix_sum] = i
            
        return -1, -1

i-1, 出錯？？？沒有搞懂。

105. 復制帶隨機指針的鏈表

挑戰

可否使用O(1)的空間

"""
Definition for singly-linked list with a random pointer.
class RandomListNode:
    def __init__(self, x):
        self.label = x
        self.next = None
        self.random = None
"""


class Solution:
    # @param head: A RandomListNode
    # @return: A RandomListNode
    def copyRandomList(self, head):
        # write your code here
        if not head:
            return None
        copied_head, map_nodes = self.copy_nodes(head)
        self.copy_link(head, map_nodes)
        return copied_head
    
    def copy_nodes(self, head):
        dummy = RandomListNode(None) # Tips
        node, pre = head, dummy
        map_nodes = {}
        while node:
            node_cp = RandomListNode(node.label)
            map_nodes[node] = node_cp
            pre.next = node_cp
            node = node.next
            pre = node_cp
        return dummy.next, map_nodes
    
    def copy_link(self, head, map_nodes):
        node = head
        while node:
            if node.random:
                map_nodes[node].random = map_nodes[node.random]
            node = node.next

124. 最長連續序列

樣例

樣例 1

輸入 : [100, 4, 200, 1, 3, 2]
輸出 : 4
解釋 : 這個最長的連續序列是 [1, 2, 3, 4]. 返回所求長度 4

說明

要求你的算法復雜度為O(n)

class Solution:
    """
    @param num: A list of integers
    @return: An integer
    """

    def longestConsecutive(self, num):
        # write your code here
        ans = 1
        uniq_num_visted = {n: False for n in num}
        for n in uniq_num_visted:
            if uniq_num_visted[n]:
                continue

            uniq_num_visted[n] = True
            while n + 1 in uniq_num_visted:
                uniq_num_visted[n + 1] = True
                n += 1
            high = n

            while n - 1 in uniq_num_visted:
                uniq_num_visted[n - 1] = True
                n -= 1
            low = n
            ans = max(ans, high-low+1)

        return ans