Gate-CS-2009 Problem 3

Gate-CS-2009 Problem 3 is a coding question that involves implementing a priority queue using a Max-Heap data structure. The problem statement involves implementing the Max-Heap data structure before implementing the priority queue operations like insert and delete-max.

Max-Heap Data Structure

A Max-Heap is a binary tree in which the value of each parent node is greater than or equal to the values of its children. The root node is the maximum value in the heap.

To implement a Max-Heap, we need to define the following operations:

1. MaxHeap() - Constructor for creating a new empty Max-Heap data structure.
2. insert(value) - Insert a new value into the Max-Heap.
3. deleteMax() - Delete the maximum value from the Max-Heap.
4. heapify() - Reorganize the Max-Heap after deletion of the maximum value.

Here is an implementation of the Max-Heap in Python:

class MaxHeap:
    def __init__(self):
        self.heap = []

    def insert(self, value):
        self.heap.append(value)
        current = len(self.heap) - 1
        parent = (current - 1) // 2
        while current > 0 and self.heap[current] > self.heap[parent]:
            self.heap[current], self.heap[parent] = self.heap[parent], self.heap[current]
            current = parent
            parent = (current - 1) // 2

    def deleteMax(self):
        if len(self.heap) == 0:
            return None
        if len(self.heap) == 1:
            return self.heap.pop()
        rootValue = self.heap[0]
        self.heap[0] = self.heap.pop()
        current = 0
        child1 = current * 2 + 1
        child2 = current * 2 + 2
        while True:
            if child2 < len(self.heap):
                if self.heap[child2] >= self.heap[child1] and self.heap[child2] > self.heap[current]:
                    self.heap[child2], self.heap[current] = self.heap[current], self.heap[child2]
                    current = child2
                elif self.heap[child1] > self.heap[current]:
                    self.heap[child1], self.heap[current] = self.heap[current], self.heap[child1]
                    current = child1
                else:
                    break
            elif child1 < len(self.heap):
                if self.heap[child1] > self.heap[current]:
                    self.heap[child1], self.heap[current] = self.heap[current], self.heap[child1]
                    current = child1
                else:
                    break
            else:
                break
            child1 = current * 2 + 1
            child2 = current * 2 + 2

        return rootValue

    def heapify(self):
        for i in range(len(self.heap) - 1, -1, -1):
            current = i
            child1 = current * 2 + 1
            child2 = current * 2 + 2
            while True:
                if child2 < len(self.heap):
                    if self.heap[child2] >= self.heap[child1] and self.heap[child2] > self.heap[current]:
                        self.heap[child2], self.heap[current] = self.heap[current], self.heap[child2]
                        current = child2
                    elif self.heap[child1] > self.heap[current]:
                        self.heap[child1], self.heap[current] = self.heap[current], self.heap[child1]
                        current = child1
                    else:
                        break
                elif child1 < len(self.heap):
                    if self.heap[child1] > self.heap[current]:
                        self.heap[child1], self.heap[current] = self.heap[current], self.heap[child1]
                        current = child1
                    else:
                        break
                else:
                    break
                child1 = current * 2 + 1
                child2 = current * 2 + 2

Priority Queue

A priority queue is a queue which each item is assigned a priority and added to the queue in such a way that the item with the highest priority is always at the front of the queue. In this problem, we need to implement a priority queue using the Max-Heap data structure which we have implemented above.

To implement a priority queue using Max-Heap, we need to define the following operations:

1. PriorityQueue() - Constructor for creating a new empty priority queue.
2. insert(value) - Insert a new value into the priority queue with its priority.
3. deleteMax() - Delete the maximum-priority value from the priority queue.
4. findMax() - Find the maximum-priority value in the priority queue.

Here is an implementation of the Priority Queue using Max-Heap in Python:

class PriorityQueue:
    def __init__(self):
        self.maxHeap = MaxHeap()

    def insert(self, value):
        self.maxHeap.insert(value)

    def deleteMax(self):
        return self.maxHeap.deleteMax()

    def findMax(self):
        return self.maxHeap.heap[0] if len(self.maxHeap.heap) > 0 else None

Conclusion

In conclusion, the Gate-CS-2009 Problem 3 involves implementing a Max-Heap and using it for implementing a priority queue. The Max-Heap data structure is a binary tree in which the value of each parent node is greater than or equal to the values of its children. The Priority Queue is a queue in which each item is assigned a priority and added to the queue in such a way that the item with the highest priority is always at the front of the queue. By properly implementing the Max-Heap data structure, we can implement the priority queue with the required operations.