Implement a method called outputSorted that sorts an array of Person objects using only a Heap. The method should take an array of Person objects and a comparator. output Sorted should initialize a Heap with the given comparator, insert the people into the heap, then extract and output each person from the heap. The array should not be modified by outputSorted. Type Person should be defined as follows: class Person { String name; int age;

Implement a method called outputSorted that sorts an array of Person objects using only a Heap. The method should take an array of Person objects and a comparator. output Sorted should initialize a Heap with the given comparator, insert the people into the heap, then extract and output each person from the heap. The array should not be modified by outputSorted. Type Person should be defined as follows: class Person { String name; int age;

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter18: Stacks And Queues

Section: Chapter Questions

Problem 16PE: The implementation of a queue in an array, as given in this chapter, uses the variable count to...

See similar textbooks

Similar questions

Design a more efficient version of HeapVector that keeps its values in order only when necessary: When values are added, they are appended to the end of the existing heap and a nonHeap flag is set to true. When values are removed, the nonHeap flag is checked and the Vector is heapified if necessary. What are the worst-case and best-case running times of the add and remove operations?
Create a more efficient HeapVector that just keeps its values in order when necessary: When values are added to the heap, they are appended to the end of the existing heap and the nonHeap flag is set to true. When values are removed, the nonHeap flag is checked, and the Vector, if necessary, is heapified. What are the worst-case and best-case add and delete operation times?
Must attach output screenshot, editable output In java Implement a generic min heap class and write a test code to test the program. Use hashmap for the update method. You can also use it for the getIndex method. public int getIndex(AnyType x) {//average case O(1) //returns the index of the item in the heap//or -1 if it isn't in the heap //return -1; }public boolean update(AnyType x) {//O(lg n) average case//or O(lg n) worst case if getIndex() is guarenteed O(1) We want an update() operation which increases (or decreases) the priority of the item. The item (or an equal item) will be provided and it should update the priority queue appropriately. The only way to do this efficiently is to use a map to map heap items to indexes so that you know where to start the update (in average case O(1) time). Without this, update() would be O(n) and not O(lg n). Therefore before you implement updating, you need to integrate a map into the code. Whenever an item is placed, moved, or removed…
Java: Write a method/programme that will take a generic linked list and make a palindrome of the list. In a seperate test programme the user can add any elements to the generic list and then this list must be made a palindrome. The output should be the original list with the palindrome list added to this list.
Given the desired order in which the manatees are to arrive down south, how do I dermine if there is any way Hugh can use the drainpipe to achive the desired order? This problem can be solved by using a stack. A stack is an ordered collected of elements that operations to push(), peek(), pop(). In Java the interface Deque has those operations. The ArrayDeque class implements the Deque Interface. Input All input is to be read from the standard input stream. The input consists of several blocks of lines and is terminated by a line with just 0. The first line of each block indicates the number of manatees 0 < N < 100,000. In each of the next lines of the block there is a permutation of the numbers 1, 2, ..., N. For N=3, the permutation 2 3 1 means that the first manatee needs to be placed at the end of line and that the second manatee needs to be placed at the front of the line. The last line of each block contains just 0 signaling the end of the block. Output For each permutation…
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}
Run the following Binary Heap code in Netbeans and provide screenshots to prove that the code runs successfully: public class BinaryHeap { private static final int d= 2; private int[] heap; private int heapSize; /** * This will initialize our heap with default size. */ public BinaryHeap(int capacity){ heapSize = 0; heap = new int[ capacity+1]; Arrays.fill(heap, -1); } /** * This will check if the heap is empty or not * Complexity: O(1) */ public boolean isEmpty(){ return heapSize==0; } /** * This will check if the heap is full or not * Complexity: O(1) */ public boolean isFull(){ return heapSize == heap.length; } private int parent(int i){ return (i-1)/d; } private int kthChild(int i,int k){ return d*i +k; } /** * This will insert new element in to heap * Complexity: O(log…
Create a birthday reminder system using a minheap such that theordering on the heap is done each day according to days remaining until the individual’s birthday. Keep in mind that when abirthday passes, the heap must be reordered.
Java 1. Implement ArrayUnorderedList<T> class which will extend ArrayList<T> by defining the following additional methods(i) public void addToFront(T element); //Adds the specified element to the front of the list.(ii) public void addToRear(T element); //Adds the specified element to the rear of the list.(iii) public void addAfter(T element, T target); //Adds the specified element after the specified target element.a. Create an object of ArrayUnorderedList<T> class and perform some add, remove, and search operations and finally print the entire Stack.
Write a program CubeSum.java that prints outall integers of the form a3 + b3 where a and b are integers between 0 and N in sortedorder, without using excessive space. That is, instead of computing an array of the N2sums and sorting them, build a minimum-oriented priority queue, initially containing(03, 0, 0), (13, 1, 0), (23, 2, 0), . . . , (N3, N, 0). Then, while the priority queue is nonempty,remove the smallest item(i3 + j3, i, j), print it, and then, if j < N, insert the item (i3 + (j+1)3,i, j+1). Use this program to find all distinct mintegers a, b, c, and d between 0 and 106such that a3 + b3 = c3 + d3
Implement a simple linked list in Python (Write source code and show output) with basic linked list operations like: (a) create a sequence of nodes and construct a linear linked list. (b) insert a new node in the linked list. (b) delete a particular node in the linked list. (c) modify the linear linked list into a circular linked list. Use this template: class Node:def __init__(self, val=None):self.val = valself.next = Noneclass LinkedList:"""TODO: Remove the "pass" statements and implement each methodAdd any methods if necessaryDON'T use a builtin list to keep all your nodes."""def __init__(self):self.head = None # The head of your list, don't change its name. It shouldbe "None" when the list is empty.def append(self, num): # append num to the tail of the listpassdef insert(self, index, num): # insert num into the given indexpassdef delete(self, index): # remove the node at the given index and return the deleted value as an integerpassdef circularize(self): # Make your list circular.…
This is a java question Given an efficient circular bent array-based queue q capable of holding 7 objects. Show the final contents of the array after the following code is executed: for (int k = 1; k <= 6; k++) q.enqueue(k);for (int k = 1; k <= 3; k++) { q.dequeue( ); q.enqueue(q.dequeue( )); } 0 1 2 3 4 5 6