Create Max Priority Queue

Author: akshayavb99

Course 2 - Data Structures in JAVA/Lecture 20 - Priority Queues I/Max Priority Queue

@@ -0,0 +1,111 @@
+/*
+Implement the class for Max Priority Queue which includes following functions -
+1. getSize -
+Return the size of priority queue i.e. number of elements present in the priority queue.
+2. isEmpty -
+Check if priority queue is empty or not. Return true or false accordingly.
+3. insert -
+Given an element, insert that element in the priority queue at the correct position.
+4. getMax -
+Return the maximum element present in the priority queue without deleting. Return -Infinity if priority queue is empty.
+5. removeMax -
+Delete and return the maximum element present in the priority queue. Return -Infinity if priority queue is empty.
+*/
+
+import java.util.*;
+
+public class PQ {
+	// Complete this class
+    private ArrayList<Integer> heap = new ArrayList<Integer>();
+	boolean isEmpty() {
+		// Implement the isEmpty() function here
+        return heap.isEmpty();
+	}
+
+	int getSize() {
+		// Implement the getSize() function here
+        return heap.size();
+	}
+
+	int getMax() {
+		// Implement the getMax() function here
+        if(heap.isEmpty())
+            return Integer.MIN_VALUE;
+        return heap.get(0);
+	}
+
+	void insert(int element) {
+		// Implement the insert() function here
+        //Insert new element at the end of the arraylist
+        heap.add(element);
+        int childIndex=heap.size()-1;
+        int parentIndex=(childIndex-1)/2;
+        
+        while(parentIndex>=0)
+        {
+            //Check if parent has lesser priority than the child. If it does, swap them
+            if(heap.get(childIndex)>heap.get(parentIndex))
+            {
+                int temp=heap.get(childIndex);
+                heap.set(childIndex, heap.get(parentIndex));
+                heap.set(parentIndex,temp);
+                
+                childIndex=parentIndex;
+                parentIndex=(childIndex-1)/2;
+                
+            }
+            else
+            {
+                return;
+            }
+        }
+        
+	}
+
+	int removeMax() {
+		// Implement the removeMax() function here
+        if(heap.isEmpty())
+            return Integer.MIN_VALUE;
+        
+        //Remove the Max element and store it
+        int maxEle=heap.get(0);
+        heap.set(0,heap.get(heap.size()-1));
+        heap.remove(heap.size()-1);
+        
+        //Start reinstating max. heap property from root to leaf
+        int parentIndex=0;
+        int leftChildIndex=2*parentIndex+1, rightChildIndex=2*parentIndex+2;
+        
+        while(leftChildIndex<heap.size())
+        {
+            int maxIndex=parentIndex;
+            if(heap.get(maxIndex)<heap.get(leftChildIndex))
+            {
+                maxIndex=leftChildIndex;
+            }
+            
+            if(rightChildIndex<heap.size())
+            {
+                if(heap.get(maxIndex)<heap.get(rightChildIndex))
+            	{
+                	maxIndex=rightChildIndex;
+            	}
+            }
+            
+            if(maxIndex==parentIndex)
+            {
+                return maxEle;
+            }
+            
+            int temp=heap.get(maxIndex);
+            heap.set(maxIndex,heap.get(parentIndex));
+            heap.set(parentIndex,temp);
+            
+            parentIndex=maxIndex;
+            leftChildIndex=2*parentIndex+1;
+            rightChildIndex=2*parentIndex+2;
+        }
+        
+        return maxEle;  
+	}
+}