(A) Implement generic class ArrayStack as discussed in the lectures having following methods: constructor, push, pop, peek, isEmpty, copy constructor, reallocate (private method). Also add following methods to this class: size: returns number of elements in the stack. contains: Search an element in the stack. If found returns true, else returns false. clear: Deletes all elements of the stack and make it empty stack. (B) Implement generic class ArrayQueue as discussed in the lectures having following methods: constructor, copy constructor, offer, poll, peek, isEmpty, reallocate(private), iterator. Inner class Iter that implements interface Iterator having methods: constructor, hasNext, next. Also add following methods to the ArrayQueue class: size: returns number of elements in the queue. contains: Search an element in the queue. If found returns true, else returns false. clear: Deletes all elements of the queue and make it empty stack.

(A) Implement generic class ArrayStack as discussed in the lectures having following methods: constructor, push, pop, peek, isEmpty, copy constructor, reallocate (private method). Also add following methods to this class: size: returns number of elements in the stack. contains: Search an element in the stack. If found returns true, else returns false. clear: Deletes all elements of the stack and make it empty stack. (B) Implement generic class ArrayQueue as discussed in the lectures having following methods: constructor, copy constructor, offer, poll, peek, isEmpty, reallocate(private), iterator. Inner class Iter that implements interface Iterator having methods: constructor, hasNext, next. Also add following methods to the ArrayQueue class: size: returns number of elements in the queue. contains: Search an element in the queue. If found returns true, else returns false. clear: Deletes all elements of the queue and make it empty stack.

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

java program: Implement generic class ArrayStack as discussed in the lectures having following methods: constructor, push, pop, peek, isEmpty, copy constructor, reallocate (private method). Also add following methods to this class: size: returns number of elements in the stack. contains: Search an element in the stack. If found returns true, else returns false. clear: Deletes all elements of the stack and make it empty stack. Implement generic class ArrayQueue as discussed in the lectures having following methods: constructor, copy constructor, offer, poll, peek, isEmpty, reallocate(private), iterator. Inner class Iter that implements interface Iterator having methods: constructor, hasNext, next. Also add following methods to the ArrayQueue class: size: returns number of elements in the queue. contains: Search an element in the stack. If found returns true, else returns false. clear: Deletes all elements of the stack and make it empty stack. Write a class called PalindromeChecker…
Implement generic class ArrayStack as discussed in the lectures having following methods: constructor, push, pop, peek, isEmpty, copy constructor, reallocate (private method). Also add following methods to this class: size: returns number of elements in the stack. contains: Search an element in the stack. If found returns true, else returns false. clear: Deletes all elements of the stack and make it empty stack.
Short answer: Answer the following in your own words: 1) Your friend says they implemented a stack as a linked list with reference pointers to both a head and the tail node (i.e. they implemented a stack as a double endedlinked list). They said this significantly improved the performance for all functions (push, pop, search, and update). Are they correct? Why or why not?
Short answer Answer the following in your own words: Your friend says they implemented a stack as a linked list with reference pointers to both a head and the tail node (i.e. they implemented a stack as a double ended linked list). They said this significantly improved the performance for all functions (push, pop, search, and update). Are they correct? Why or why not? Another friend implemented a queue as a linked list with only a head pointer (no tail node). She said this made performance of all functions (insert, remove, search, and update) categorically equal to a queue as a linked list with a head and a tail node. Is she correct? Why or why not?
Please be thorough with explanation (a) Consider implementing a stack as a class that relies on a singly linked list, maintaining pointers to both the start and end of the singly linked list in the main object. You consider two possibilities. The first is to push (insert) to the beginning and pop (remove) from the beginning of the linked list. The second is to push to the end and pop from the end of the linked list. Is one of these possibilities better than the other? Briefly explain your answer.
Answer the following in your own words: Your friend says they implemented a stack as a linked list with reference pointers to both a head and the tail node (i.e. they implemented a stack as a double ended linked list). They said this significantly improved the performance for all functions (push, pop, search, and update). Are they correct? Why or why not? Another friend implemented a queue as a linked list with only a head pointer (no tail node). She said this made performance of all functions (insert, remove, search, and update) categorically equal to a queue as a linked list with a head and a tail node. Is she correct? Why or why not?
Implement a method transfer in class LinkedStack. This method should transfer all elements of a stack sourceS to another stack targetS so that the element that starts at the top of sourceS is the first one to be inserted in targetS, and the element at the bottom of sourceS ends up at the top of targetS. The operation should result in sourceS being an empty stack. Test this method in the main method of LinkedStack. package stacks;public class LinkedStack<E> implements Stack<E> {/** The primary storage for elements of the stack */private SinglyLinkedList<E> list = new SinglyLinkedList<>(); // an empty list/** Constructs an initially empty stack. */public LinkedStack() { } // new stack relies on the initially empty list@Overridepublic int size() { return list.size(); }@Overridepublic boolean isEmpty() { return list.isEmpty(); }@Overridepublic void push(E element) { list.addFirst(element); }@Overridepublic E top() { return list.first(); }@Overridepublic E pop() {…
In Java please create a generic stack code and implement these methods peek() returns a reference to the item at the top of the stack without removing it from the stack contains(T t) is a boolean method that returns true if the stack contains t, the parameter, otherwise returns false. The stack contains t if at least one T on the stack is equal to t using the equals() method. Note that there is always an available equals() method in Java, because Object, the common parent of all classes, contains one. Implement this method without using the contains()method of the list.
Implementing a Stack ADT using a linked solution. The implementations are linked Nodes. class Node: def __init__(self, data, node=None): # Initialize this node, insert data, and set the next node if any self.data = data self.chain = node class SubSetStack: def __init__(self, data=None): # Initialize this stack, and store data if it exists def push(self, data): # Add data to the beginning of the stack def pop(self): # Remove the element at the beginning of the stack. # Return the data in the element at the beginning of the stack, or None if the stack is empty def top(self): # Return the data in the element at the beginning but does not remove it. # Return None if stack is empty. def __len__(self): # Return the number of elements in the stack def subset_sum(target, sub_list): # Returns True if Target can be formed from sub_list repeated # some arbitrary number of times. In the above function a Node…
Consider the implementation of the Ordered Linked list class, implement the following functions as part of the class definition: ▪ index(item) returns the position of item in the list. It needs the item and returns the index. Assume the item is in the list.   ▪ pop() removes and returns the last item in the list. It needs nothing and returns an item. Assume the list has at least one item.   ▪ pop_pos(pos) removes and returns the item at position pos. It needs the position and returns the item. Assume the item is in the list.   ▪ a function that counts the number of times an item occurs in the linked list ▪ a function that would delete the replicate items in the linked list (i.e. leave one occurrence only of each item in the linked list) Your main function should do the following: ▪ Generate 15 random integer numbers in the range from 1 to 5.▪ Insert each number (Item in a node) in the appropriate position in a linked list, so you will have a sorted linked list in ascending order.▪…
Suppose you are trapped on a desert island with nothing but a priority queue, and you need to implement a stack. Complete the following class that stores pairs (count, element) where the count is incremented with each insertion. Recall that make_pair(count, element) yields a pair object, and that p.second yields the second component of a pair p. The pair class defines an operator< that compares pairs by their first component, and uses the second component only to break ties.Code: #include <iostream>#include <queue>#include <string>#include <utility> using namespace std; class Stack{public: Stack(); string top(); void pop(); void push(string element);private: int count; priority_queue<pair<int, string>> pqueue;}; Stack::Stack(){ /* Your code goes here */} string Stack::top(){ /* Your code goes here */} void Stack::pop(){ /* Your code goes here */} void Stack::push(string element){ /* Your code goes here */} int main(){ Stack…
Can i get this question with a detailed explanation Write a generic class called GenericStack<T> that represents a stack structure. A stack structure follow the strategy last-in-first-out, which means that the last element added to the stack, is the first to be taken out. The GenericStack class has the following attributes and methods: --An attribute ArrayList<T> elements which represents the elements of the stack.(All of you refer collection framework for ArrayList. or you can use an array to hold the elements of Stack.)[Refer the following links to have intro on ArrayList: https://www.w3schools.com/java/java_arraylist.asp, https://www.geeksforgeeks.org/arraylist-in-java/] --A constructor that creates the ArrayList or an Array --A method push(T e) which adds the element to the ArrayList<T> or array. --A method pop() which removes the last element of the ArrayList<T> (last element added), if the list is not already empty and returns it. --A method print() which…