Java programming questionNeed help with question: C 8.47C 8.47: To implement the preorder method of the AbstractTree class, we relied on the convenience of creating a snapshot. Reimplement a preorder method that creates a lazy iterator. (See Section 7.4.2 for discussion of iterators.) 7.4. Iterators123456789101112131415161718192021222324252627282930313233343536373839404142434411-nested ArrayIterator class/*** A (nonstatic) inner class. Note well that each instance contains an implicit* reference to the containing list, allowing it to access the list's members.*/private class ArrayIterator implements Iterator {private int j = 0;private boolean removable = false;// index of the next element to report// can remove be called at this time?*** Tests whether the iterator has a next object.* @return true if there are further objects, false otherwise*/public boolean hasNext() { return j < size; } // size is field of outer instance/*** Returns the next object in the iterator.** @return next object* @throws NoSuch Element Exception if there are no further elements*/public E next() throws NoSuch Element Exception {if (j == size) throw new NoSuch ElementException("No next element");removable = true; // this element can subsequently be removedreturn data[j++]; // post-increment j, so it is ready for future call to next}285*** Removes the element returned by most recent call to next.* @throws IllegalStateException if next has not yet been called* @throws IllegalStateException if remove was already called since recent nextj--;removable = false;public void remove() throws IllegalStateException {if (!removable) throw new IllegalStateException("nothing to remove");ArrayList.this.remove(j-1); // that was the last one returned// next element has shifted one cell to the left// do not allow remove again until next is called}}//-end of nested ArrayIterator class/** Returns an iterator of the elements stored in the list. */public Iterator iterator() {return new Arraylterator(); // create a new instance of the inner class}Code Fragment 7.13: Code providing support for ArrayList iterators. (This shouldbe nested within the ArrayList class definition of Code Fragments 7.2 and 7.3.) 7.4.2 Implementing IteratorsThere are two general styles for implementing iterators that differ in terms of whatwork is done when the iterator instance is first created, and what work is done eachtime the iterator is advanced with a call to next().A snapshot iterator maintains its own private copy of the sequence of elements,which is constructed at the time the iterator object is created. It effectively recordsa "snapshot" of the sequence of elements at the time the iterator is created, and istherefore unaffected by any subsequent changes to the primary collection that mayoccur. Implementing snapshot iterators tends to be very easy, as it requires a simpletraversal of the primary structure. The downside of this style of iterator is that itrequires O(n) time and O(n) auxiliary space, upon construction, to copy and storea collection of n elements.A lazy iterator is one that does not make an upfront copy, instead perform-ing a piecewise traversal of the primary structure only when the next() method iscalled to request another element. The advantage of this style of iterator is thatit can typically be implemented so the iterator requires only O(1) space and O(1)construction time. One downside (or feature) of a lazy iterator is that its behavioris affected if the primary structure is modified (by means other than by the itera-tor's own remove method) before the iteration completes. Many of the iterators inJava's libraries implement a “fail-fast” behavior that immediately invalidates suchan iterator if its underlying collection is modified unexpectedly.We will demonstrate how to implement iterators for both the ArrayList andLinked Positional List classes as examples. We implement lazy iterators for both,including support for the remove operation (but without any fail-fast guarantee).Iterations with the ArrayList classWe begin by discussing iteration for the ArrayList class. We will have it im-plement the Iterable interface. (In fact, that requirement is already part ofJava's List interface.) Therefore, we must add an iterator() method to that classdefinition, which returns an instance of an object that implements the Iteratorinterface. For this purpose, we define a new class, Arraylterator, as a nonstaticnested class of ArrayList (i.e., an inner class, as described in Section 2.6). Theadvantage of having the iterator as an inner class is that it can access private fields(such as the array A) that are members of the containing list.Our implementation is given in Code Fragment 7.13. The iterator() methodof ArrayList returns a new instance of the inner Arraylterator class. Each iteratormaintains a field j that represents the index of the next element to be returned. It isinitialized to 0, and when j reaches the size of the list, there are no more elements toreturn. In order to support element removal through the iterator, we also maintaina boolean variable that denotes whether a call to remove is currently permissible.

In this question we will answer about pre-order stack java

Answered: Java programming question Need help…

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