Heaps Code Goal: Given the following MinHeap class, implement the remove() method.Requirements: Your code should be as efficient as possible. You may not assume any other methodin the MinHeap class is implemented. You may assume that everything from java.util is imported.public class MinHeap {private T[] backingArray;int size;* Removes and returns the smallest element in the MinHeap.** The order property of the heap must be maintained after removing.@return the smallest data in the heap@throws java.util. NoSuch Element Exception if the heap is emptypublic T remove() {// YOUR CODE HERE, USE THE NEXT PAGE IF NEEDEDBecause this method is on your homework, this code cannot be provided :(Please refer to feedback on your homework.

Solution- According to the question we create an program in which we perform various method like…

Answered: Heaps Code

Engineering

Computer Science

Heaps Code

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

2.2.14 Merging sorted queues. Develop a static method that takes two queues of sorteditems as arguments and returns a queue that results from merging the queues intosorted order.2.2.15 Bottom-up queue mergesort. Develop a bottom-up mergesort implementationbased on the following approach: Given N items, create N queues, each containing oneof the items. Create a queue of the N queues. Then repeatedly apply the merging operation of Exercise 2.2.14 to the first two queues and reinsert the merged queue at the end.Repeat until the queue of queues contains only one queue.
2- Implement a class template MinHeap that has the following declaration using c++ class MinHeap{ Node* heap; //an array of nodes int _size; //size of arraypublic: Node extractMin(); //returns & removes the node with minimum cost void buildMinHeap(Node[],int);// allocates array then builds a min-heap from an array of struct Node with the given size void minHeapify(int i, int n);//restores the min-heap property for the “heap” array using the given index and size n void decreaseKey(char label,int newCost);//decreases the node that has the given label to newCost int parent(int i);//returns the index of the parent of i int getSize();//returns size of the heap bool inHeap(char);//checks if the node with the given label is in the heap};
(Java) In this task, a skip list data structure should be implemented. You can follow the followinginstructions:- Implement the class NodeSkipList with two components, namely key node and arrayof successors. You can also add a constructor, but you do not need to add anymethod.- In the class SkipList implement a constructor SkipList(long maxNodes). The parameter maxNodes determines the maximal number of nodes that can be added to askip list. Using this parameter we can determine the maximal height of a node, thatis, the maximal length of the array of successors. As the maximal height of a nodeit is usually taken the logarithm of the parameter. Further, it is useful to constructboth sentinels of maximal height.- In the class SkipList it is useful to write a method which simulates coin flip andreturns the number of all tosses until the first head comes up. This number representsthe height of a node to be inserted.- In the class SkipList implement the following methods:(i) insert, which…
Revise Heap , using a genericparameter and a Comparator for comparing objects. Define the class as follows:class HeapWithComparator<E> {private Comparator<? super E> comparator; // For comparing elements public HeapWithComparator() {// Implement no−arg constructor by creating a comparator fornatural order}public HeapWithComparator(Comparator<? super E> comparator) {this.comparator = comparator;}// Implement all add, remove, and getSize method}
void build (int[] elts, int N); // The "magic" build operation which constructs a heap in O(N) time// the first parameter is an array that contains all the elements that// will go into the heap; the second parameter tells how many elements// there are (so that the array "elts" can be larger than the number// of elements in it... we do not depend on elts.length to determine// the size of heap we build.//// The method works as follows: // first: the heap that is doing the build will do a clear() // and it will lose any elements already in that heap// second: load the elements in parameter "elts" into the heap// array directly ( a O(N) copying action )// third: perform the "bubble down" operations that a build// requires on the heap array// // When testing look to find a sequence of elements that let you // get two different heap structure when you // 1) create a heap from N separate inserts// 2) do this build method//// Here is one such sequence: 101, 37, 26, 19, 15, 12, 9, 2, 3, 5////…
JAVA PROGRAMMING Q4.1: You have two sequences of mutually-comparable items to sort: The sequences are identical in terms of their sizes, their items, and the current (unsorted) order of those items. One sequence is in an array and the other is in a linked list. For the array and the link list, make an argument for why the quick sort would be best for one and the merge sort for the other. In the identified situation, give a quantitative answer based on big-O and other technical factors, not just a qualitative answer. Address the specifics of the two algorithms -- their operations, time efficiency, money use, etc. Assume no optimization Q4.2: Explain and/or illustrate the specific changes made in each pass of an Insertion Sort on the following data: 47 4 22 13 9 12
Implement the class MaxHeapPQ that implements the interface MaxPriorityQueue using the maximum-oriented heap. Add a method min() to find the minimal key of a maximum-oriented heap priority queue. note: - create a file MaxHeapPQ.java . You may start with the Java program with this file(the code below) and also provide output screenshot. import java.util.Iterator; import java.util.ArrayList; class MaxHeapPQ<K extends Comparable<K>> implements MaxPriorityQueue<K> { private K data[]; private int size; private int capacity; // constructors public MaxHeapPQ() { capacity = 100; size = 0; data = (K[]) new Comparable[capacity]; } public MaxHeapPQ(int c) { capacity = c; size = 0; data = (K[]) new Comparable[capacity]; } // required priority queue methods public boolean isEmpty(){ //ADD CODE } public void add(K x) throws Exception { //ADD CODE } public K removeMax() throws Exception { if (size <= 0) throw new Exception("Priority Queue Empty"); //ADD CODE } // auxiliary…
Implement Circular Queue ADT using a circular doubly linked list, the ADT have to be in following convention: Template Class CircularQueue { DoubleList dll; ///////////////////////// Setter/Getters Constructors/ destructor Virtual bool Enqueue(type value)=0; Virtual bool Dequeue(type &value)=0; Virtual bool Front (type &value)=0; Virtual bool Rear (type &value)=0; Virtual void Display( )=0; //Any other function } Task is to extend this class by MyCircularQueue and override the above all pure virtual functions. In C++
In PriorityQueue.java, write code for the following new functions:1. public boolean add( PriorityQueueNode x )This function adds a new node x to the priority queue. The node is added tothe heap by comparison of the rating attribute. It involves the “percolateup” process and returns true when finished. 2. public PriorityQueueNode remove( )This function removes the minimum element of the priority queue and returnsit. It involves a call to percolateDown( int hole ). 3. private void percolateDown( int hole )This function takes the position of the next available hole in the priority queueand uses it to bubble the elements through the heap until the heap property isrestored. 4. public void display( )This function prints out a formatted tree representation of the priority queueshowing only the rating of each node. The output should resemble that of atree. Tip: you may use the StringBuilder class and the Stringformat( ) method. Empty nodes in the tree can be replaced with “--”.Example output…
Complete the following class in java all the methods according to the requirements shown in the rubric import jsjf.exceptions.*; /** * LinkedHeap implements a heap. * * @author Java Foundations * @version 4.0 */ public class LinkedHeap<T> extends LinkedBinaryTree<T> implements HeapADT<T> { publicHeapNode<T> lastNode; publicLinkedHeap() { super(); } /** * Adds the specified element to this heap in the appropriate * position according to its key value. * * @param obj the element to be added to the heap */ publicvoidaddElement(Tobj) { HeapNode<T> node = newHeapNode<T>(obj); if (root == null) root=node; else { HeapNode<T> nextParent = getNextParentAdd(); if (nextParent.getLeft() == null) nextParent.setLeft(node); else nextParent.setRight(node); node.setParent(nextParent); } lastNode = node; modCount++; if (size() > 1) heapifyAdd(); } /** * Returns the node that will be the parent of the new node * * @return the node that will be the…
In this task, a skip list data structure should be implemented. You can follow the followinginstructions:- Implement the class NodeSkipList with two components, namely key node and arrayof successors. You can also add a constructor, but you do not need to add anymethod.- In the class SkipList implement a constructor SkipList(long maxNodes). The parameter maxNodes determines the maximal number of nodes that can be added to askip list. Using this parameter we can determine the maximal height of a node, thatis, the maximal length of the array of successors. As the maximal height of a nodeit is usually taken the logarithm of the parameter. Further, it is useful to constructboth sentinels of maximal height.- In the class SkipList it is useful to write a method which simulates coin flip andreturns the number of all tosses until the first head comes up. This number representsthe height of a node to be inserted.- In the class SkipList implement the following methods:(i) insert, which accepts…
Java Consider the following class definition for an array-based stack implementation:pubic class Stack { private int[] m_array; private int m_index; public Stack(int cap) { m_array = new int[cap]; m_index = 0; } public void push(int v) { if (m_index == m_array.length) throw new RuntimeException("push attempted on a full stack"); else { m_array[m_index] = v; m_index++; } }} Follow the steps below to create a class SpecialStack with required instance variables and methods.a. Make sure that the SpecialStack class inherits from Stack. b. Declare two private instance variables: a boolean variable m_multiply, and an int variable m_number.c. Create a constructor that takes three parameters: an int cap, a boolean multiply, and an int number.d. The constructor should call the constructor of the super class and initialize the instance variables properly.e. Override the push method so it verifies if m_multiply is…