Java programming Questionhelp wih R 7.10:R-7.10 Reimplement the ArrayStack class, from Section 6.1.2, using dynamic arrays to support unlimited capacity. 6.1.2 A Simple Array-Based Stack ImplementationAs our first implementation of the stack ADT, we store elements in an array, nameddata, with capacity N for some fixed N. We oriented the stack so that the bottomelement of the stack is always stored in cell data [0], and the top element of thestack in cell data[t] for index t that is equal to one less than the current size of thestack. (See Figure 6.2.)1234567891011121314151617181 public class ArrayStack implements Stack {public static final int CAPACITY=1000;private E[] data;private int t = −1;public ArrayStack() { this(CAPACITY);public ArrayStack(int capacity) {data (E[]) new Object[capacity];PATEEN3852021data: A | B012tN-1Figure 6.2: Representing a stack with an array; the top element is in cell data[t].Recalling that arrays start at index 0 in Java, when the stack holds elementsfrom data [0] to data[t] inclusive, it has size t + 1. By convention, when the stack isempty it will have t equal to −1 (and thus has size t + 1, which is 0). A completeJava implementation based on this strategy is given in Code Fragment 6.2 (withJavadoc comments omitted due to space considerations).23}19 public E pop() {2425=26 }==22 data[t] = null;t--;return answer;CDEFG}}public int size() { return (t + 1); }public boolean isEmpty() { return (t == -1); }public void push(E e) throws IllegalStateException {if (size()data[++t] = e;}public E top() {if (isEmpty()) return null;return data[t];KLMdata.length) throw new IllegalState Exception("Stack is full");// increment t before storing new itemif (isEmpty()) return null;E answer = data[t];// default array capacity// generic array used for storage// index of the top element in stack} // constructs stack with default capacity// constructs stack with given capacity// safe cast; compiler may give warning// dereference to help garbage collectionCode Fragment 6.2: Array-based implementation of the Stack interface.

Dear Student, The new implementation of ArrayStack class using Dynamic arrays is given below -

Answered: Reimplement the ArrayStack class, f

Engineering

Computer Science

Reimplement the ArrayStack class, f

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 1TF

See similar textbooks

Similar questions

PP 12.4 The array implementation in this chapter keeps the top variablepointing to the next array position above the actual top of thestack. Rewrite the array implementation such that stack[top] isthe actual top of the stack. PP 12.5 There is a data structure called a drop-out stack that behaves likea stack in every respect except that if the stack size is n, whenthe n + 1 element is pushed, the first element is lost. Implement adrop-out stack using an array. (Hint: A circular array implementation would make sense.)
Consider the Stack ADT: Stack: push(x) adds x to top of stack pop() removes top element of stack and returns it size() returns number of elements in stack Select all options that allow for an efficient implementation based on the discussions from class. For any array implementation, you can assume the array is large enough so that making a larger one is not needed when pushing an item to the stack. Using an array with the top at the front of the array. Using an array with the top at the back of the array. Using a singly linked list with the top at the head of the list. Using a singly linked list with the top at the tail of the list. ENG
PP 12.4 The top variable in the chapter's array implementation is kept above the stack's actual top by pointing to the following array position. Change the array implementation so that stack[top] actually refers to the stack's top. PP 12.5 A data structure known as a drop-out stack functions exactly like a stack, with the exception that if the stack size is n, the first element is lost when the n + 1 element is pushed. Apply an array to a drop-out stack. (Hint: It would make sense to implement a circular array.)
Stack: push(x) adds x to top of stack pop() removes top element of stack and returns it size() returns number of elements in stack Select all options that allow for an efficient implementation based on the discussions from class. For any array implementation, you can assume the array is large enough so that making a larger one is not needed when pushing an item to the stack. Using an array with the top at the front of the array. Using an array with the top at the back of the array. Using a singly linked list with the top at the head of the list. Using a singly linked list with the top at the tail of the list. None of these choices allows for an efficient implementation of all methods.
A data structure known as a drop-out stack functions exactly like a stack, with the exception that if the stack size is n, the first element is lost when the n + 1 element is pushed. Use an array to implement a drop-out stack. (Hint: It would make sense to implement a circular array.)
Stacks are an important data structure in their own right and they may be implemented in several ways. Implement a stack as an array and i. Write functions to perform the following operations on it. With each operation explain the time complexity associated with it when performeda. Push() b. pop() c. size() d. peek()ii. Briefly explain any two problems when stacks are implemented as an array.
4. Sort elements in an array-based stack in ascending order, i.e. make the smallest element to be the top element of the stack. E.g. given the stack elements (from bottom to top): 90, 70, 80, 10, sort the elements to make the stack elements become (from bottom to top): 90, 80, 70, 10. The only data structure you can use is array-based stack. In addition to the given stack, you can use only one extra stack to store some temporary data. Given a stack st, use one extra stack, tmpst, to store temporary data. Here are some hints of the idea. Pop out the top element of st to a variable tmp. If the stack tmpst is empty, push tmp onto tmpst; if tmpst is not empty, pop out its top element and push that element onto st until the top element of tmpst is smaller than tmp, then push tmp onto tmpst .. a. Write a program to implement the stack based sorting. b. Take the input (90, 70, 80, 10) as an example. c. Print all the push and pop operations in proper format. d. At the end, print the sorted…
A data structure known as a drop-out stack functions exactly like a stack, with the exception that if the stack size is n, the first element is lost when the n + 1 element is pushed. Apply an array to a drop-out stack. (Hint: It would make sense to implement a circular array.)
Example function void f() { int array[10]; read(array, 10); reverse(array, 10); print(array, 10); } Stack Frame saved $ra = 4 bytes int array[10] (40 bytes) Figure 7.6: Example of a function f and its corresponding stack frame 5. Suppose we rewrite function f (Figures 7.6) to have an integer parameter n. The local array is now declared to have n integers (rather than 10). This means that the size of the stack frame size of function f will depend on n. Rewrite the function f in MIPS assembly language. Hint: you may use the $fp register (in addition to $sp) to implement the function f. void f(int n) { int array[n]; read(array, n); reverse(array, n); print(array, n); }
1. Write a program which should implement a stack using static array of size 10 (10 elementsarray), elements of array should be of integer (int) type. User will input values to be pushed onstack and also number of elements to be popped from stack. Your program should display thevalue of elements which are being popped from stack. Program should also calculate anddisplay the average of elements which have been popped from stack.
Introduction For this assignment, you are to write a program which implements a Sorted List data structure using a circular array-based implementation and a driver program that will test this implementation. The Sorted List ADT is a linear collection of data in which all elements are stored in sorted order. Your implementation has to store a single int value as each element of the list and support the following operations: 1. add(x) – adds the integer x to the list. The resulting list should remain sorted in increasing order. The time complexity of this operation should be 0(N), where N is the size of the list. 2. removefirst() - deletes the first integer from the list and returns its value. The remaining list should remain sorted. Time complexity of this operation should be 0(1). 3. removelast() – deletes the last integer from the list and returns its value. The remaining list should remain sorted. Time complexity of this operation should be 0(1). 4. exists(x) – returns true if the…
A drop-out stack is a data structure that acts just like a stack except that if the stack size is n, and the n + 1 element is pushed, the first element is lost. Using an array, create a drop-out stack. (Hint: A circular array implementation would be appropriate.)