January 24, Abstract Data Types (ADTs) An ADT is an abstraction of a data structure.

Transcription

1 Lists CSE 2011 Winter 2007 January 24, Abstract Data Types (ADTs) An ADT is an abstraction of a data structure. An ADT specifies: data stored operations on the data error conditions associated with operations 2 1

2 Example of ADT A simple stock trading system Data stored: buy and sell orders Operations: order buy (stock, number_of_shares, unit_price) order sell (stock, number_of_shares, unit_price) void cancel (order) Error conditions: Buy/sell a non-existent stock Cancel a non-existent order 3 List ADT The List ADT extends the notion of array by storing a linear sequence of arbitrary objects An element can be accessed, inserted or removed by specifying its position or rank (number of elements preceding it). Definition of position is consistent with Java array indexing: position of A i is i. An exception is thrown if an incorrect position is specified (e.g., a negative index). 4 2

3 List Interface public interface List<AnyType> extends Collection<AnyType> AnyType get( int idx ); AnyType set( int idx, AnyType newval ); void add( int idx, AnyType x ); void remove( int idx ); ListIterator<AnyType> listiterator( int pos ); int size() boolean isempty(); 5 List Implementation Array Linked list Singly linked or doubly linked?? 6 3

4 Array-Based Implementation Use an array V of size N A variable n keeps track of the size of the vector (number of elements stored) How is n maintained? 7 Insertion at Position r In the worst case (r = 0), this takes θ(n) time. In the best case (r = n), this takes θ(1) time. Running time: O(n). Assuming each rank is equally likely to be chosen, average running time is θ(n) (prove this!). 8 4

5 Removal In the worst case (r = 0), this takes θ(n) time. In the best case (r = n 1), this takes θ(1) time. Running time: O(n). Assuming each rank is equally likely to be chosen, average running time is θ(n). 9 Other Methods size() isempty() get(int idx) set(int idx, AnyType newval) Source code: pp

6 get() and set() public AnyType get( int idx ) if( idx < 0 idx >= size( ) ) throw new ArrayIndexOutOfBoundsException ( "Index " + idx + "; size " + size( ) ); return theitems[ idx ]; public AnyType set( int idx, AnyType newval ) if( idx < 0 idx >= size( ) ) throw new ArrayIndexOutOfBoundsException ( "Index " + idx + "; size " + size( ) ); AnyType old = theitems[ idx ]; theitems[ idx ] = newval; return old; 11 add() public void add( int idx, AnyType x ) if( theitems.length == size( ) ) ensurecapacity( size( ) * ); for( int i = thesize; i > idx; i-- ) theitems[ i ] = theitems[ i - 1 ]; theitems[ idx ] = x; thesize++; 12 6

7 remove() public AnyType remove( int idx ) AnyType removeditem = theitems[ idx ]; for( int i = idx; i < size( ) - 1; i++ ) theitems[ i ] = theitems[ i + 1 ]; thesize--; return removeditem; 13 Limitation of Array Implementation Can t store more than N objects Alternatives: Extendable arrays Linked lists 14 7

8 Extendable Array Implementation When add() is called and an overflow occurs (n = N): Allocate a new array T of capacity 2N Copy contents of the original array V into the first half of the new array T Set V = T Perform the insertion using new array V Note: when the number of elements in the list goes below a threshold (e.g., N/4), shrink the array by half the current size N of the array. 15 Time Analysis Push : inserting an element to be the last element of a list (or top of a stack) add(e) Step 1: if overflow then extend the array; Step 2: push e to new array; Proposition 1: Let S be a list implemented by means of an extendable array V as described before. The total time to perform a series of n push operations in S, starting from S being empty and V having size N = 1, is O(n). 16 8

9 Time Analysis (cont d) Step 2 takes O(n) (each push takes O(1)) Step 1: Allocate a new array T of capacity 2N Copy V[i] to T[i] for i = 0, 1,, N 1 Set V = T If the array is extended k times, then n = 2 k The total number of copies is: k 1 = 2 k 1 = n 1 = O(n) Step 1 + Step 2 = O(n) 17 Increment Strategies java.util.arraylist and java.util.vector are similar to our List ADT They also use extendable arrays capacityincrement determines how the array grows: capacityincrement = 0: array size doubles capacityincrement = c > 0: array adds c new cells Proposition 2: If we create an initially empty java.util.vector object with a fixed positive capacityincrement value, then performing a series of n push operations on this vector takes Ω(n 2 ) time. Ω(n 2 ): takes at least time n

10 Increment Strategies (cont.) Step 2 takes O(n) Step 1: Let a be the initial size of array V Let capacityincrement = c If the array is extended k times then n = a + ck The total number of copies is: (a) + (a+c) + (a+2c) + + (a+(k 1)c) = ak + c(1+2+ +(k 1)) = ak + ck(k 1)/2 = θ(k 2 ) = θ(n 2 ) We infer Ω(n 2 ) from θ(n 2 ) What is the better increment strategy? 19 Which Linked List? 20 10

11 Implementation of Linked List Nodes Singly linked list private static class Node<AnyType> public AnyType data; public Node<AnyType> next; Doubly linked list private static class Node<AnyType> public AnyType data; public Node<AnyType> prev; public Node<AnyType> next; Better running time in many cases (see the next slide). Needs less space. Simpler code in some cases. 21 Singly or Doubly Linked List? Given a pointer p pointing to a node in the list, what is the running time of the following operations? Singly linked list Insert a new element after p Remove the element pointed to by p Doubly linked list Insert a new element after p Remove the element pointed to by p 22 11

12 Linked List Implementation Doubly linked lists are more efficient! For access, insertion and deletion, we must locate the element at position r, by hopping. Can start from the header or the trailer, and travel at most half the list. 23 Insertion at Position 1 the list before insertion create a new node for insertion the list after insertion 24 12

13 getnode() private Node<AnyType> getnode( int idx, int lower, int upper ) Node<AnyType> p; if( idx < lower idx > upper ) throw new IndexOutOfBoundsException ( "getnode index: " + idx + "; size: " + size( ) ); if( idx < size( ) / 2 ) p = beginmarker.next; for( int i = 0; i < idx; i++ ) p = p.next; else p = endmarker; for( int i = size( ); i > idx; i-- ) p = p.prev; return p; 25 add() public void add( int idx, AnyType x ) addbefore( getnode( idx, 0, size( ) ), x ); private void addbefore( Node<AnyType> p, AnyType x ) Node<AnyType> newnode = new Node<AnyType>( x, p.prev, p ); newnode.prev.next = newnode; p.prev = newnode; thesize++; 26 13

14 Deletion at Position 2 the list before deletion deleting a node after deletion 27 remove() public AnyType remove( int idx ) return remove( getnode( idx ) ); private AnyType remove( Node<AnyType> p ) p.next.prev = p.prev; p.prev.next = p.next; thesize--; return p.data; 28 14

15 Header and Trailer Nodes Special cases: Adding an element to an empty list. Removing the only element from a list. To avoid these special cases, use 2 dummy nodes which have the same structure as normal nodes: header sentinel (prev pointer is null) trailer sentinel (next pointer is null) 29 Next time Stacks Queues Iterators IMPORTANT NOTE: The source code for MyArrayList and MyLinkedList classes as given in the textbook contains several bugs. Check for the list of bugs. The correct source code is posted at