PLEASE READ THIS FIRST! _____________________Please write in java. Add comments but make the comments short. No need for really long comments. Please keep code very neat and simple , dont add anything unneccesary in the code if you weren't instructed to do so. If youve answered this before please dont copy and paste from a previous question! (Rewrite it in another way)..... Also be sure to read the instructions below carefully. The two files that are attached are screenshots of the textbook's MAX-HEAP Example. You will be creating a mini-heap from that example. But the Instructions below explains everything you'll be doing. NO THIS is not a homework assignment, it's practice work. Please type the code out so that I can copy and paste it into my IDE and see the output for my self but also still provide a screenshot of your output!INSTRUCTIONS FOR QUESTION BELOW!!_____________________________You may use the Java Libraries for solving this problem. We recommend using java.util.* The star “ * ” acts as a wildcard and allows you to use the entire java.util library. The heap presented in the screenshot is also known as a max-heap, in which each node is greater than or equal to any of it's children. A min-heap is a heap in which each node is less than or equal to any of its children. Min-heaps are often used to implement priority queues. Revise the Heap class in the screenshot to implement a min-heap. (The max heap example begins on the screenshot that says "Listings 23.9" at the top).Use the following logic:Write a main method that will accept 5 numbers, and put them in a min-heapRemove them from the min heap, printing one at a time as they are removed, to show that the list is sortedHint: The screenshotted textbook example is for a MAX heap; you must alter that example to reflect a MIN heap – think about it ! ```java// Find the maximum between two childrenint leftChildIndex = 2 * currentIndex + 1;int rightChildIndex = 2 * currentIndex + 2;int maxIndex = leftChildIndex;if (leftChildIndex >= list.size()) break; // The tree is a heapif (rightChildIndex < list.size()) { if (list.get(maxIndex).compareTo( list.get(rightChildIndex)) < 0) { maxIndex = rightChildIndex; // compare two children }}// Swap if the current node is less than the maximumif (list.get(currentIndex).compareTo( list.get(maxIndex)) < 0) { E temp = list.get(maxIndex); list.set(maxIndex, list.get(currentIndex)); list.set(currentIndex, temp); // swap with the larger child currentIndex = maxIndex;}else break; // The tree is a heap}return removedObject;}/** Get the number of nodes in the tree **/public int getSize() { return list.size();}```### ExplanationThis code is part of a heap sort implementation. It describes a method used to maintain the heap property of a binary heap stored in a list.- **Lines 45-47**: Calculate the indices of the left and right children of a given node `currentIndex` in a complete binary tree. These indices are based on the formula for heap-based tree structures.- **Lines 48-49**: Check if the `leftChildIndex` is beyond the size of the list, which indicates that the subtree rooted at `currentIndex` is already a valid heap.- **Lines 50-53**: Determine if the right child exists and compare the values at `maxIndex` and `rightChildIndex`. If the right child value is greater, update `maxIndex`.- **Lines 56-63**: Check if the value at `currentIndex` is less than the value at `maxIndex`. If so, swap them and update `currentIndex` to `maxIndex` to continue sifting down the heap. Otherwise, if no swap is needed, exit the loop since the tree satisfies the heap property.- **Line 67**: Returns the removed object after maintaining the heap property.- **Lines 72-75**: A method `getSize()` that returns the number ```javaLISTING 23.9 Heap.java1 public class Heap> {2 private java.util.ArrayList list = new java.util.ArrayList();3 4 /** Create a default heap */5 public Heap() {6 }7 8 /** Create a heap from an array of objects */9 public Heap(E[] objects) {10 for (int i = 0; i < objects.length; i++)11 add(objects[i]);12 }13 14 /** Add a new object into the heap */15 public void add(E newObject) {16 list.add(newObject); // Append to the heap17 int currentIndex = list.size() - 1; // The index of the last node18 19 while (currentIndex > 0) {20 int parentIndex = (currentIndex - 1) / 2;21 // Swap if the current object is greater than its parent22 if (list.get(currentIndex).compareTo(23 list.get(parentIndex)) > 0) {24 E temp = list.get(currentIndex);25 list.set(currentIndex, list.get(parentIndex));26 list.set(parentIndex, temp);27 }28 else29 break; // The tree is a heap now30 31 currentIndex = parentIndex;32 }33 }34 35 /** Remove the root from the heap */36 public E remove() {37 if (list.size() == 0) return null;38 39 E removedObject = list.get(0);40 list.set(0, list.get(list.size() - 1));41 list.remove(list.size() - 1);42 43 int currentIndex = 0;44 while (currentIndex < list.size()) {```**Explanation of Key Code Segments:**- **Lines 1-2**: Declaration of the class `Heap` with a generic type `` that extends `Comparable`. An `ArrayList` is used to store heap elements.- **Line 5**: Default constructor for the heap.- **Lines 9-12**: Constructor to create a heap from an array of objects. It iterates through the array and adds each element to the heap.- **Lines

import java.util.*;class Heap{// vector for storing heapprivate Vector<Integer> A; // constructor: set a custom initial capacity for vectorpublic Heap(int capacity) {A = new Vector(capacity);}// returns parent of `A[i]`private int parent(int i){// base case: root nodeif (i == 0) {return 0;}return (i - 1) / 2;} // return left child of `A[i]`private int LEFT(int i) {return (2*i + 1);} // return right child of `A[i]`private int RIGHT(int i) {return (2*i + 2);} // swap values at two indexesvoid swap(int x, int y){Integer temp = A.get(x);A.setElementAt(A.get(y), x);A.setElementAt(temp, y);}// Recursive heapify-down procedure. Here, the node at index `i`// and its two direct children violate the heap propertyprivate void heapify_down(int i){// get left and right child of node at index `i`int left = LEFT(i);int right = RIGHT(i); int smallest = i;// compare `A[i]` with its left and right child// and find the smallest valueif (left < A.size() && A.get(left) < A.get(i)) {smallest = left;}if (right < A.size() && A.get(right) < A.get(smallest)) {smallest = right;}if (smallest != i){// swap with a child having smaller valueswap(i, smallest);// call heapify-down on the childheapify_down(smallest);}} // Recursive heapify-up procedureprivate void heapify_up(int i){// check if the node at index `i` and its parent violates// the heap propertyif (i > 0 && A.get(parent(i)) > A.get(i)){// swap the two if heap property is violatedswap(i, parent(i));// call heapify-up on the parentheapify_up(parent(i));}}// insert a specified key into the heappublic void add(Integer key){// insert a new element at the end of the vectorA.addElement(key); // get element index and call heapify-up procedureint index = A.size() - 1;heapify_up(index);} // Function to remove and return an element with the highest priority// (present at the root). It returns null if the queue is emptypublic Integer heapremove(){// if the heap is empty, throw an exceptionif (A.size() == 0) {return -1;} // element with the highest priorityint root = A.get(0);// replace the root of the heap with the last element of the vectorA.setElementAt(A.lastElement(), 0);A.remove(A.size() - 1); // call heapify-down on the root nodeheapify_down(0); // return root elementreturn root;}// Function to return an element with the highest prioritypublic Integer peek(){// if the heap has no elements, throw an exceptionif (A.size() == 0) {return -1;}// otherwise, return the top (first) elementreturn A.get(0);}} public class Main{public static void main (String[] args){Heap hp = new Heap(10); hp.add(8);hp.add(12);hp.add(15);hp.add(5);hp.add(45); hp.heapremove(); System.out.println("Top element of heap is: " + hp.peek());}}Screenshot of the code:Output :