Queues — FIFO, Deque and Priority Queue

from collections import deque
 
queue = deque()
queue.append(10)    # enqueue — O(1)
queue.append(20)
queue.append(30)
queue.popleft()     # dequeue — O(1), returns 10

from collections import deque
 
def bfs(graph, start):
    visited = set([start])
    queue = deque([start])
    order = []
 
    while queue:
        node = queue.popleft()
        order.append(node)
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
 
    return order

from collections import deque
 
dq = deque()
dq.append(1)        # add to right
dq.appendleft(0)    # add to left
dq.pop()            # remove from right
dq.popleft()        # remove from left

def max_sliding_window(arr, k):
    dq = deque()   # stores indices, decreasing order of values
    result = []
 
    for i, val in enumerate(arr):
        # Remove elements outside window
        while dq and dq[0] < i - k + 1:
            dq.popleft()
        # Remove smaller elements from back
        while dq and arr[dq[-1]] < val:
            dq.pop()
        dq.append(i)
        if i >= k - 1:
            result.append(arr[dq[0]])  # front is always the max
 
    return result
 
max_sliding_window([1,

import heapq
 
# Min heap (default in Python)
pq = []
heapq.heappush(pq, 3)
heapq.heappush(pq, 1)
heapq.heappush(pq, 2)
heapq.heappop(pq)   # returns 1 (smallest)
 
# Max heap — negate values
max_pq = []
heapq.heappush(max_pq, -3)
heapq.heappush(max_pq, -1)
-heapq.heappop(max_pq)  # returns 3 (largest)

def top_k_frequent(nums, k):
    count = {}
    for n in nums:
        count[n] = count.get(n, 0) + 1
 
    # Min heap of size k
    heap = []
    for num, freq in count.items():
        heapq.heappush(heap, (freq, num))
        if len(heap) > k:
            heapq.heappop(heap)  # remove least frequent
 
    return [num for freq, num in heap]