class PriorityQueue(object): """PriorityQueue: a partially ordered queue with methods to enqueue items in priority order and to access and dequeue its highest priority item. Item pairs are stored in a binary min heap for its efficient operations.""" def __init__(self): """Initialize this priority queue.""" # Initialize new binary min heap to store items in this priority queue self.heap = BinaryMinHeap() def __repr__(self): """Return a string representation of this priority queue.""" return 'PriorityQueue({} items, front={})'.format( self.size(), self.front()) def is_empty(self): """Return True if this priority queue is empty, or False otherwise.""" return self.heap.is_empty() def size(self): """returns the number of items in the queue""" return self.heap.size() def length(self): """Return the number of items in this priority queue.""" return self.heap.size() def enqueue(self, item, priority): """Insert the given item into this priority queue in order according to the given priority.""" # Insert given item into heap in order according to given priority return self.heap.insert((priority, item)) def front(self): """Return the item at the front of this priority queue without removing it, or None if this priority queue is empty.""" if self.is_empty(): return None # Return minimum item from heap return self.heap.get_min()[1] def dequeue(self): """Remove and return the item at the front of this priority queue, or raise ValueError if this priority queue is empty.""" if self.is_empty(): raise ValueError('Priority queue is empty and has no front item') # Remove and return minimum item from heap return self.heap.get_min()[1] def push_pop(self, item, priority): """Remove and return the item at the front of this priority queue, and insert the given item in order according to the given priority. This method is more efficient than calling dequeue and then enqueue.""" if self.is_empty(): raise ValueError('Priority queue is empty and has no front item') # Replace and return minimum item from heap return self.heap.replace_min((priority, item))[1]
def test_insert_and_get_one_item(self): heap = BinaryMinHeap() assert heap.is_empty() is True heap.insert(5) assert heap.is_empty() is False assert heap.size() == 1 assert heap.get_min() == 5 assert heap.items == [5]
def test_insert_and_get_many_random_items(self): heap = BinaryMinHeap() items = random.sample(range(1000), 50) for index, item in enumerate(items): heap.insert(item) assert heap.size() == index + 1 min_item = min(items[:index + 1]) assert heap.get_min() == min_item assert heap.size() == len(items)
def test_insert_and_get_many_items(self): heap = BinaryMinHeap() items = [9, 25, 86, 3, 29, 5, 55] for index, item in enumerate(items): heap.insert(item) assert heap.size() == index + 1 min_item = min(items[:index + 1]) assert heap.get_min() == min_item assert heap.size() == len(items) assert heap.items == [3, 9, 5, 25, 29, 86, 55]
def get_suggestion(org_handle, handle_array, k=2) -> [str]: assert len(handle_array) >= k suggestion_min_heap = BinaryMinHeap() handle_set = set(org_handle) # O(c) for handle in handle_array: # O(n) if suggestion_min_heap.size() < k: curr_score = get_score(handle_set, handle) # O(c) suggestion_min_heap.insert((handle, curr_score)) # O(k) elif suggestion_min_heap.get_min()[1] > len( handle): # Check whether to get the score or not continue else: curr_score = get_score(handle_set, handle) # O(c) if curr_score > suggestion_min_heap.get_min()[1]: suggestion_min_heap.replace_min((handle, curr_score)) return [x[0] for x in suggestion_min_heap.items] # O(k)
class PriorityQueue: def __init__(self): self._heap = BinaryMinHeap() self._max_priority = 0 self._min_priority = 0 def _update_minmax(self, priority): if priority > self._max_priority: self._max_priority = priority if priority < self._min_priority: self._min_priority = priority @property def size(self): return self._heap.size @property def front(self): if self.is_empty() is False: return self._heap.get_min().value else: return None def dequeue(self): return self._heap.delete_min().value def enqueue(self, item): self.insert_back(item) def push_pop(self, item): self.insert_back(item) return self._heap.delete_min().value def is_empty(self): return self._heap.is_empty() def insert(self, item, priority): self._heap.insert(KVHolder(priority, item)) self._update_minmax(priority) def insert_front(self, item): priority = self._min_priority - 1 self.insert(item, priority) def insert_back(self, item): priority = self._max_priority + 1 self.insert(item, priority)
def test_insert_and_get_one_item(self): heap = BinaryMinHeap() heap.insert(5) assert heap.size() == 1 assert heap.get_min() == 5 assert heap.items == [5]
def test_get_min_on_empty_heap(self): heap = BinaryMinHeap() with self.assertRaises(ValueError): heap.get_min()
class PriorityQueue(object): """ PriorityQueue: a partially ordered queue with methods to enqueue items in priority order and to access and dequeue its highest priority item. Item pairs are stored in a binary min heap for its efficient operations. """ def __init__(self): """Initialize this priority queue.""" # Initialize new binary min heap to store items in this priority queue self.heap = BinaryMinHeap() def __repr__(self): """Return a string representation of this priority queue.""" return 'PriorityQueue({} items, front={})'.format( self.length(), self.front()) # def __str__(self): # pass def is_empty(self): """Return True if this priority queue is empty, or False otherwise.""" return self.heap.is_empty() def length(self): """Return the number of items in this priority queue.""" return self.heap.size() def enqueue(self, item, priority): """ Insert the given item into this priority queue in order according to the given priority. """ # Insert given item into heap in order according to given priority new_item = (item, priority) self.heap.insert(new_item) def front(self): """ Return the item at the front of this priority queue without removing it, or None if this priority queue is empty. """ if self.length() == 0: return None return self.heap.get_min()[0] def dequeue(self): """ Remove and return the item at the front of this priority queue, or raise ValueError if this priority queue is empty. """ if self.length() == 0: raise ValueError('Priority queue is empty and has no front item') # delete the min element front_elem = self.heap.delete_min() return front_elem[0] def push_pop(self, item, priority): """ Remove and return the item at the front of this priority queue, and insert the given item in order according to the given priority. This method is more efficient than calling dequeue and then enqueue. """ if self.length() == 0: raise ValueError('Priority queue is empty and has no front item') # store the old front item old_front = self.front() # replace the item at the 0th element with new item and its priority self.heap.items[0] = (item, priority) # print(f"new front item: {self.front()}") return old_front[0]