# Priority Queue using Linked List

Implement Priority Queue using Linked Lists.

• push(): This function is used to insert a new data into the queue.
• pop(): This function removes the element with the highest priority from the queue.
• peek() / top(): This function is used to get the highest priority element in the queue without removing it from the queue.

Priority Queues can be implemented using common data structures like arrays, linked-lists, heaps and binary trees.

Prerequisites :

The list is so created so that the highest priority element is always at the head of the list. The list is arranged in descending order of elements based on their priority. This allow us to remove the highest priority element in O(1) time. To insert an element we must traverse the list and find the proper position to insert the node so that the overall order of the priority queue is maintained. This makes the push() operation takes O(N) time. The pop() and peek() operations are performed in constant time.

Algorithm :

• Step 1: Create new node with DATA and PRIORITY
• Step 2: Check if HEAD has lower priority. If true follow Steps 3-4 and end. Else goto Step 5.
• Step 3: NEW -> NEXT = HEAD
• Step 4: HEAD = NEW
• Step 5: Set TEMP to head of the list
• Step 6: While TEMP -> NEXT != NULL and TEMP -> NEXT -> PRIORITY > PRIORITY
• Step 7: TEMP = TEMP -> NEXT
[END OF LOOP]
• Step 8: NEW -> NEXT = TEMP -> NEXT
• Step 9: TEMP -> NEXT = NEW
• Step 10: End

• Step 1: Set the head of the list to the next node in the list. HEAD = HEAD -> NEXT.
• Step 2: Free the node at the head of the list
• Step 3: End

• Step 1: Return HEAD -> DATA
• Step 2: End

Below is the implementation of the algorithm :

## Python3

 # Python3 code to implement Priority Queue  # using Singly Linked List     # Class to create new node which includes # Node Data, and Node Priority class PriorityQueueNode:          def __init__(self, value, pr):              self.data = value     self.priority = pr     self.next = None            # Implementation of Priority Queue class PriorityQueue:            def __init__(self):                    self.front = None                # Method to check Priority Queue is Empty      # or not if Empty then it will return True     # Otherwise False     def isEmpty(self):                    return True if self.front == None else False            # Method to add items in Priority Queue      # According to their priority value     def push(self, value, priority):                    # Condition check for checking Priority         # Queue is empty or not         if self.isEmpty() == True:                            # Creating a new node and assigning             # it to class variable             self.front = PriorityQueueNode(value,                                             priority)                            # Returning 1 for successful execution             return 1                         else:                            # Special condition check to see that             # first node priority value             if self.front.priority > priority:                                    # Creating a new node                 newNode = PriorityQueueNode(value,                                              priority)                                    # Updating the new node next value                 newNode.next = self.front                                    # Assigning it to self.front                 self.front = newNode                                    # Returning 1 for successful execution                 return 1                                else:                                    # Traversing through Queue until it                 # finds the next smaller priority node                 temp = self.front                                    while temp.next:                                            # If same priority node found then current                     # node will come after previous node                     if priority <= temp.next.priority:                         break                                            temp = temp.next                                    newNode = PriorityQueueNode(value,                                              priority)                 newNode.next = temp.next                 temp.next = newNode                                    # Returning 1 for successful execution                 return 1             # Method to remove high priority item     # from the Priority Queue     def pop(self):                    # Condition check for checking          # Priority Queue is empty or not         if self.isEmpty() == True:             return                    else:                              # Removing high priority node from             # Priority Queue, and updating front             # with next node             self.front = self.front.next             return 1                    # Method to return high priority node      # value Not removing it     def peek(self):                    # Condition check for checking Priority          # Queue is empty or not          if self.isEmpty() == True:             return         else:             return self.front.data                    # Method to Traverse through Priority     # Queue     def traverse(self):                    # Condition check for checking Priority         # Queue is empty or not          if self.isEmpty() == True:             return "Queue is Empty!"         else:             temp = self.front             while temp:                 print(temp.data, end = " ")                 temp = temp.next    # Driver code if __name__ == "__main__":            # Creating an instance of Priority     # Queue, and adding values     # 7 -> 4 -> 5 -> 6     pq = PriorityQueue()     pq.push(4, 1)     pq.push(5, 2)     pq.push(6, 3)     pq.push(7, 0)            # Traversing through Priority Queue     pq.traverse()            # Removing highest Priority item     # for priority queue     pq.pop()      # This code is contributed by himanshu kanojiya

## Javascript



Output:

7 4 5 6

Time Complexities and Comparison with Binary Heap

peek()    push()    pop()
-----------------------------------------
Linked List |   O(1)      O(n)      O(1)
|
Binary Heap |   O(1)    O(Log n)   O(Log n)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next