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}

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}

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter17: Linked Lists

Section: Chapter Questions

Problem 10PE

See similar textbooks

Similar questions

complete all the implementation of the member functions listed in the class interface for the following header file. #ifndef _LINKEDSTACK#define _LINKEDSTACK #includeusing namespace std;templateclass LinkedStack{private:Node *top; Node *getCurrentTop() { return top; }public: Stack(); bool isEmpty(); bool push(ItemType newItem); bool pop(); ItemType peek(); void clean(); bool display();};#endif
Given Class:- import java.util.*; // Iterator, Comparatorpublic class BinarySearchTree<T> implements BSTInterface<T>{protected BSTNode<T> root; // reference to the root of this BSTprotected Comparator<T> comp; // used for all comparisonsprotected boolean found; // used by removepublic BinarySearchTree() // Precondition: T implements Comparable// Creates an empty BST object - uses the natural order of elements.{root = null;comp = new Comparator<T>(){public int compare(T element1, T element2){return ((Comparable)element1).compareTo(element2);}};}public BinarySearchTree(Comparator<T> comp) // Creates an empty BST object - uses Comparator comp for order// of elements.{root = null;this.comp = comp;}public boolean isFull()// Returns false; this link-based BST is never full.{return false;}public boolean isEmpty()// Returns true if this BST is empty; otherwise, returns false.{return (root == null);}public T min()// If this BST is empty, returns null;//…
package circularlinkedlist;import java.util.Iterator; public class CircularLinkedList<E> implements Iterable<E> { // Your variablesNode<E> head;Node<E> tail;int size; // BE SURE TO KEEP TRACK OF THE SIZE // implement this constructorpublic CircularLinkedList() {} // I highly recommend using this helper method// Return Node<E> found at the specified index// be sure to handle out of bounds casesprivate Node<E> getNode(int index ) { return null;} // attach a node to the end of the listpublic boolean add(E item) {this.add(size,item);return false; } // Cases to handle// out of bounds// adding to empty list// adding to front// adding to "end"// adding anywhere else// REMEMBER TO INCREMENT THE SIZEpublic void add(int index, E item){ } // remove must handle the following cases// out of bounds// removing the only thing in the list// removing the first thing in the list (need to adjust the last thing in the list to point to the beginning)// removing the last…
Add the following method in the BST class that returns aniterator for traversing the elements in a BST in preorder./** Return an iterator for traversing the elements in preorder */java.util.Iterator<E> preorderIterator()
Consider the following implementation of the node and doubly linked-list: template <class type>class node{public:type info;node<type> * next;// nextnode<type> * prev;//back }; template <class type>class doubly_linked_list{//data membersprivate:node<type> *head, *tail;int length;public:doubly_linked_list(){head = tail = NULL;length = 0;}bool isEmpty(){ // return (head==NULL);if (head == NULL)return true;elsereturn false;} void Append(type e){node<type> *newnode = new node<type>;newnode->info = e;if (isEmpty()){newnode->next = NULL;newnode->prev = NULL;head = newnode;tail = newnode;}else{tail->next = newnode;newnode->prev = tail;newnode->next = NULL;tail = newnode;}++length; } void Display(){if (isEmpty()) { cout << "The linked list is empty !!!!"; return; }cout << "list elements: ";node<type> * current = head;while (current != NULL){cout << current->info << " ";current =…
given class:- import java.util.*; // Iterator, Comparatorpublic class BinarySearchTree<T> implements BSTInterface<T>{protected BSTNode<T> root; // reference to the root of this BSTprotected Comparator<T> comp; // used for all comparisonsprotected boolean found; // used by removepublic BinarySearchTree() // Precondition: T implements Comparable// Creates an empty BST object - uses the natural order of elements.{root = null;comp = new Comparator<T>(){public int compare(T element1, T element2){return ((Comparable)element1).compareTo(element2);}};}public BinarySearchTree(Comparator<T> comp) // Creates an empty BST object - uses Comparator comp for order// of elements.{root = null;this.comp = comp;}public boolean isFull()// Returns false; this link-based BST is never full.{return false;}public boolean isEmpty()// Returns true if this BST is empty; otherwise, returns false.{return (root == null);}public T min()// If this BST is empty, returns null;//…
Queue example – make this generic, instead of a Queue of Customer. public class Queue { private ArrayList<Customer> line; public Queue() { line = null; } public void enqueue (Customer c) { Customer newc = new Customer (c); // copy constructor plateful.add(newc); } public Customer dequeue (Customer c) { Customer newc = line.get(0); plateful.remove(0); return newc; } } // end of class definition
java: Implement the class Node public class Node { private char data; private Node nextNode; //implements default constructor //implements parameterize constructor take integer as input in parameter a assign that integer to data and assign null to nextNode //implement setters and getters } Implement the class Stack having one member having type Node public class Stack { private Node top; public void push (); public Node pop (); public Boolean isEmpty(); return true if stack is empty // implements all its function and write time complexity of its function
Consider the following implementation of the node and doubly linked-list: template <class type>class node{public:type info;node<type> * next;// nextnode<type> * prev;//back }; template <class type>class doubly_linked_list{//data membersprivate:node<type> *head, *tail;int length;public:doubly_linked_list(){head = tail = NULL;length = 0;}bool isEmpty(){ // return (head==NULL);if (head == NULL)return true;elsereturn false;} void Append(type e){node<type> *newnode = new node<type>;newnode->info = e;if (isEmpty()){newnode->next = NULL;newnode->prev = NULL;head = newnode;tail = newnode;}else{tail->next = newnode; newnode->prev = tail;newnode->next = NULL;tail = newnode;}++length; } void Display(){if (isEmpty()) { cout << "The linked list is empty !!!!"; return; }cout << "list elements: ";node<type> * current = head;while (current != NULL){cout << current->info << " ";current =…
7. Given a Queue Q, write a non-generic method that finds the maximum element in the Queue. You may use only queue operations. No other data structure can be used other than queues. The Queue must remain intact after finding the maximum value. Assume the class that has the findMax method implements Comparable. The header of the findMax method: public Comparable findMax(Queue q)
StackQueuePostfix A. Pointer_based queuea. Define the class PoiQueue with no implementation; i.e. declare the datamembers, and the function members only (Enqueue, Dequeue, IsEmpty,GetHead etc.).b. Implement the Enqueue method of the above classB. Array_based non-circular queue:a. Define the class Queue using one dimensional array representation with noimplementation; i.e. declare the data members, and the function membersonly (Enqueue, Dequeue, IsEmpty, GetHead etc.).b. Implement the Denqueue method of the above class
Part 1: Without using generics 1. Define the interface NumFilter. The interface has a single method named predicate that takes one Integer argument and returns a boolean value. interface NumFilter { boolean predicate (Integer n); } A typical implementation of the predicate method would be as follows: - returns true if the integer n satisfy the condition of the filter - else returns false.