Computer Science CS221 Test 4 Name

Size: px

Start display at page:

Download "Computer Science CS221 Test 4 Name"

Elfrieda Hunter
6 years ago
Views:

1 Computer Science CS221 Test 4 Name 1. We looked at two different concrete classes that implemented the Queue interface, QueueAr which used an array as the underlying data structure, and QueueLi which used a linked list. Discuss the differences between these two classes and the advantages/disadvantages of each. 4/15/1999 Page 1 of 11

2 2. Suppose you have a list whose elements are in ascending order (i.e. the list was built using the SortListItr class to do insertions). This means that any duplicates in the list will be in adjacent nodes within the list. You are to write a new method for the SortedListItr called removeduplicates, which removes all duplicate values from the list, leaving only one copy of each value. So, if (for example) the list contained the sequence 2 -> 2-> 5-> 8->8->8->10 before a call to removeduplicates, it would contain 2->5->8->10 after it completed. When the method completes, current should refer to the first item of the list, or the header node if the list was empty. 4/15/1999 Page 2 of 11

3 3. Attached to this test, you will find a listing of the DoublyLinkedListNode class and the DoublyLinkedListItr class. Write the insertafter method for the DoublyLinkedListItr class. You can assume that the DoublyLinkedList class has the same methods as the LinkedList class (i.e. isempty( ) and makeempty( )). 4. Write down a modified version of the remove method of the LinkedListItr class (which is attached to this test) which removes all instances of the value x from the list. (The current version of remove only removes the first instance of x that it encounters.) 4/15/1999 Page 3 of 11

4 5. The general List interface is actually composed of two subinterfaces, the List interface and the ListItr interface. Discuss the reasons for this organization, and show a small example of how a ListItr object might be used. 4/15/1999 Page 4 of 11

5 Computer Science Test 4 Spring Below you will find a picture of the current state of a LinkedList object called alist and a LinkedListItr object called aitr. Redraw the picture to reflect the situation after the following sequence of operations have been performed (you will probably want to work this out on scratch paper then copy your final diagram onto this page; also note that I have left out any try/catch constructs that would be needed for this code to keep it simple): aitr.advance( ); MyInteger x = aitr.retrieve(); aitr.insert((object) new MyInteger(x.intValue() + 1)); aitr.advance(); aitr.remove(aitr.retrieve()); aitr.first(); aitr.find((object) new MyInteger(59)); aitr.advance(); alist header aitr thelist current a) Draw your modified diagram here b) What operations would you need to perform on aitr if you wanted to add the value 0 at the beginning of the list? Pledge: On my honor, I have neither given nor received unauthorized help on this work. Signed: 4/15/1999 Page 5 of 11

6 package DataStructures; class DoublyLinkedListNode // Constructors ListNode( Object theelement ) this( theelement, null, null ); ListNode( Object theelement, ListNode n, ListNode p) element = theelement; next = n; prev = p; // Friendly data; accessible by other package routines Object element; ListNode next; ListNode prev; public class DoublyLinkedListItr implements ListItr // The usual iterator methods appear here, including your // definition for insertafter() List header. protected DoublyLinkedList thelist; // List header Current position. protected ListNode current; // Current position 4/15/1999 Page 6 of 11

7 package DataStructures; import Exceptions.*; import Supporting.*; import Supporting.Comparable; // SortListItr class; maintains current position // // CONSTRUCTION: with a LinkedList to which SortListItr // is permanently bound // // ******************PUBLIC OPERATIONS********************* // void insert( x ) --> Insert x in sorted order // void remove( x ) --> Remove x // void removenext( ) --> Remove item after current position // boolean find( x ) --> Set current position to view x // void zeroth( ) --> Set current position to prior to first // void first( ) --> Set current position to first // void advance( ) --> Advance // boolean isinlist( ) --> True if at valid position in list // Object retrieve --> Return item in current position // ******************ERRORS******************************** // Exceptions thrown for illegal access, insert, or remove. public class SortListItr extends LinkedListItr * Construct the list. * The result of the construction is the same as for ListItr. anylist a LinkedList object to which this iterator is * permanently bound. This constructor is provided for * convenience. If anylist is not a LinkedList object, a * ClassCastException will result. public SortListItr( List anylist ) throws ClassCastException super( anylist ); * Overridden to generate an exception. An insert routine * that accepts a Comparable object should be used. x an Object that is attempted to be inserted. ItemNotFound thrown if this method is executed. public void insert( Object x ) throws ItemNotFound if( x instanceof Comparable ) insert( (Comparable) x ); else throw new ItemNotFound( SortListItr insert + requires an object of type Comparable ); * Insert in sorted order. * Assumes that the list is already sorted. * current is set to the inserted node on success. 4/15/1999 Page 7 of 11

8 * No exceptions are thrown. x the item to insert. public void insert( Comparable x ) LinkedListItr prev = new LinkedListItr( thelist ); LinkedListItr curr = new LinkedListItr( thelist ); prev.zeroth( ); curr.first( ); while( curr.isinlist( ) && ((Comparable)(curr.retrieve( ))).lessthan( x ) ) curr.advance( ); prev.advance( ); try prev.insert( x ); catch( ItemNotFound e ) // Cannot happen current = prev.current; 4/15/1999 Page 8 of 11

9 package DataStructures; import Supporting.MyInteger; // For main only import Exceptions.*; import java.io.*; * Linked list implementation of the list iterator * using a header node. Mark Allen Weiss LinkedList public class LinkedListItr implements ListItr * Construct the list. anylist a LinkedList object to which this iterator is * permanently bound. This constructor is provided for * convenience. If anylist is not a LinkedList object, a * ClassCastException will result. public LinkedListItr( List anylist ) throws ClassCastException this( ( LinkedList ) anylist ); * Construct the list. * As a result of the construction, the current position is * the first item, unless the list is empty, in which case * the current position is the zeroth item. anylist a LinkedList object to which this iterator is * permanently bound. public LinkedListItr( LinkedList anylist ) thelist = anylist; current = thelist.isempty( )? thelist.header : thelist.header.next; * Insert after the current position. * current is set to the inserted node on success. x the item to insert. ItemNotFound if the current position is null. public void insert( Object x ) throws ItemNotFound if( current == null ) throw new ItemNotFound( Insertion error ); ListNode newnode = new ListNode( x, current.next ); current = current.next = newnode; * Set the current position to the first node containing an item. * current is unchanged if x is not found. x the item to search for. 4/15/1999 Page 9 of 11

10 true if the item is found, false otherwise. public boolean find( Object x ) ListNode itr = thelist.header.next; while( itr!= null &&!itr.element.equals( x ) ) itr = itr.next; if( itr == null ) return false; current = itr; return true; * Remove the first occurrence of an item. * current is set to the first node on success; * remains unchanged otherwise. x the item to remove. ItemNotFound if the item is not found. public void remove( Object x ) throws ItemNotFound ListNode itr = thelist.header; while( itr.next!= null &&!itr.next.element.equals( x ) ) itr = itr.next; if( itr.next == null ) throw new ItemNotFound( Remove fails ); itr.next = itr.next.next; current = thelist.header; // Bypass deleted node // Reset current * Remove the item after the current position. * current is unchanged. true if successful false otherwise. public boolean removenext( ) if( current == null current.next == null ) return false; current.next = current.next.next; return true; * Test if the current position references a valid list item. true if the current position is not null and is * not referencing the header node. public boolean isinlist( ) return current!= null && current!= thelist.header; 4/15/1999 Page 10 of 11

11 * Return the item stored in the current position. the stored item or null if the current position * is not in the list. public Object retrieve( ) return isinlist( )? current.element : null; * Set the current position to the header node. public void zeroth( ) current = thelist.header; * Set the current position to the first node in the list. * This operation is valid for empty lists. public void first( ) current = thelist.header.next; * Advance the current position to the next node in the list. * If the current position is null, then do nothing. * No exceptions are thrown by this routine because in the * most common use (inside a for loop), this would require the * programmer to add an unnecessary try/catch block. public void advance( ) if( current!= null ) current = current.next; List header. protected LinkedList thelist; // List header Current position. protected ListNode current; // Current position 4/15/1999 Page 11 of 11

Computer Science CS221 Test 2 Name. 1. Give a definition of the following terms, and include a brief example. a) Big Oh

Computer Science CS221 Test 2 Name 1. Give a definition of the following terms, and include a brief example. a) Big Oh b) abstract class c) overriding d) implementing an interface 10/21/1999 Page 1 of