Presentation is loading. Please wait.

Presentation is loading. Please wait.

DATA STRUCTURES AND ALGORITHMS Lecture Notes 3 Prepared by İnanç TAHRALI.

Similar presentations


Presentation on theme: "DATA STRUCTURES AND ALGORITHMS Lecture Notes 3 Prepared by İnanç TAHRALI."— Presentation transcript:

1 DATA STRUCTURES AND ALGORITHMS Lecture Notes 3 Prepared by İnanç TAHRALI

2 2 ROAD MAP Abstract Data Types (ADT) The List ADT Implementation of Lists Array implementation of lists Linked list implementation of lists Cursor implementation of lists

3 3 Abstract Data Types (ADT) Definition : Is a set of operation Mathematical abstraction No implementation detail Example : Lists, sets, graphs, stacks are examples of ADT along with their operations

4 4 Why ADT ? Modularity divide program into small functions easy to debug and maintain easy to modify group work Reuse do some operations only once Easy to change of implementation transparent to the program

5 5 THE LIST ADT Ordered sequence of data items called elements A 1, A 2, A 3, …,A N is a list of size N size of an empty list is 0 A i+1 succeeds A i A i-1 preceeds A i position of A i is i first element is A 1 called head last element is A N called tail Operations ?

6 6 THE LIST ADT Operations PrintList Find FindKth Insert Delete Next Previous MakeEmpty

7 7 THE LIST ADT Example: the elements of a list are 34, 12, 52, 16, 12 Find (52) 3 Insert (20, 3) 34, 12, 52, 20, 16, 12 Delete (52) 34, 12, 20, 16, 12 FindKth (3) 20

8 8 Implementation of Lists Many Implementations Array Linked List Cursor (linked list using arrays)

9 9 ROAD MAP Abstract Data Types (ADT) The List ADT Implementation of Lists Array implementation of lists Linked list implementation of lists Cursor implementation of lists

10 10 Array Implementation of List ADT Need to define a size for array High overestimate (waste of space) Operations Running Times PrintList O(N) Find Insert O(N) (on avarage half needs to be moved) Delete FindKth Next O(1) Previous

11 11 Array Implementation of List ADT Disadvantages : insertion and deletion is very slow need to move elements of the list redundant memory space it is difficult to estimate the size of array

12 12 ROAD MAP Abstract Data Types (ADT) The List ADT Implementation of Lists Array implementation of lists Linked list implementation of lists Cursor implementation of lists

13 13 Linked List Implementation of Lists Series of nodes not adjacent in memory contain the element and a pointer to a node containing its succesor Avoids the linear cost of insertion and deletion !

14 14 Linked List Implementation of Lists Insertion into a linked list

15 15 Linked List Implementation of Lists Deletion from a linked list

16 16 Linked List Implementation of Lists Need to know where the first node is the rest of the nodes can be accessed No need to move the list for insertion and deletion operations No memory waste

17 17 Linked List Implementation of Lists Linked List Array PrintList O(N) (traverse the list) O(N) Find FindKth (L,i) O(i) O(1) Delete O(1) O(N) Insert

18 18 Programming Details There are 3 special cases for linked lists Insert an element at the front of the list there is no really obvious way Delete an element from the front of the list changes the start of the list Delete an element in general requires to keep track of the node before the deleted one How can we solve these three problems ?

19 19 Programming Details Keep a header node in position 0 Write a FindPrevious routine returns the predecessor of the cell To delete the first element FindPrevious routine returns the position of header Use of header node is controversial !

20 20 Type decleration for link list node template class List; // Incomplete declaration. template class ListItr; // Incomplete declaration. template class ListNode { ListNode( const Object & theElement = Object( ), ListNode*n=NULL) : element(theElement),next(n) {} Object element; ListNode *next; friend class List ; friend class ListItr ; };

21 21 Iterator class for linked lists template class ListItr { public: ListItr( ) : current( NULL ) { } bool isPastEnd( ) const { return current == NULL; } void advance( ) { if( !isPastEnd( ) ) current = current->next; } const Object & retrieve( ) const { if( isPastEnd( ) ) throw BadIterator( ); return current->element; } private: ListNode *current; // Current position ListItr(ListNode *theNode):current( theNode ) { } friend class List ; // Grant access to constructor };

22 22 List class interface template class List { public: List( ); List( const List & rhs ); ~List( ); bool isEmpty( ) const; void makeEmpty( ); ListItr zeroth( ) const; ListItr first( ) const; void insert( const Object & x, const ListItr & p ); ListItr find( const Object & x ) const; ListItr findPrevious( const Object & x ) const; void remove( const Object & x ); const List & operator=( const List & rhs ); private: ListNode *header; };

23 23 Function to print a list template void printList( const List &the List) { if (theList.isEmpty()) cout<< Empty list << endl; else { ListItr itr = theList.first(); for (; !itr.isPastEnd(); itr.advance()) cout << itr.retrieve() << ; } cout << endl; }

24 24 Some list one-liners /* Construct the list */ template List ::List( ) { header = new ListNode ; } /* Test if the list is logically empty */ template bool List ::isEmpty( ) const { return header->next == NULL; }

25 25 Some list one liners /* Return an iterator representing the header node template ListItr List ::zeroth( ) const { return ListItr ( header ); } /* Return an iterator representing the first node in the list. This operation is valid for empty lists. */ template ListItr List ::first( ) const { return ListItr ( header->next ); }

26 26 Find routine /* Return iterator corresponding to the first node containing an item x. Iterator isPastEnd if item is not found. */ template ListItr List ::find( const Object & x ) const { ListNode *itr = header->next; while( itr != NULL && itr->element != x ) itr = itr->next; return ListItr ( itr ); }

27 27 Deletion routine for linked lists /* Remove the first occurrence of an item x. */ template void List ::remove( const Object & x ) { ListItr p = findPrevious( x ); if( p.current->next != NULL ) { ListNode *oldNode = p.current->next; p.current->next = p.current->next->next; delete oldNode; }

28 28 findPrevious-the find routine for use with remove /*Return iterator prior to the first node containing an item x. template ListItr List ::findPrevious( const Object & x ) const { ListNode *itr = header; while( itr->next != NULL && itr->next->element != x ) itr = itr->next; return ListItr ( itr ); }

29 29 Insertion routine for linked lists /* Insert item x after p. */ template void List ::insert( const Object & x, const ListItr & p ) { if( p.current != NULL ) p.current->next = new ListNode ( x, p.current->next ); }

30 30 makeEmpty and List destructor /* Make the list logically empty. */ template void List ::makeEmpty( ) { while( !isEmpty( ) ) remove( first( ).retrieve( ) ); } /* Destructor */ template List ::~List( ) { makeEmpty( ); delete header; }

31 31 List copy routines: operator= /*Deep copy of linked lists. template const List & List ::operator=( const List & rhs ) { ListItr ritr = rhs.first( ); ListItr itr = zeroth( ); if( this != &rhs ) { makeEmpty( ); for( ; !ritr.isPastEnd( ); ritr.advance( ),itr.advance( )) insert( ritr.retrieve( ), itr ); } return *this; }

32 32 List copy routines : copy constructor /* Copy constructor template List ::List( const List & rhs ) { header = new ListNode ; *this = rhs; }

33 33 Doubly Linked List Traversing list backwards not easy with regular lists Insertion and deletion more pointer fixing Deletion is easier Previous node is easy to find

34 34 Circulary Linked List Last node points the first

35 35 ROAD MAP Abstract Data Types (ADT) The List ADT Implementation of Lists Array implementation of lists Linked list implementation of lists Cursor implementation of lists

36 36 Cursor Implementation of Linked List Problems with linked list implementation: Same language do not support pointers ! Then how can you use linked lists ? new and free operations are slow Actually not constant time

37 37 Cursor Implementation of Linked List SOLUTION: Implement linked list on an array called CURSOR

38 38 Cursor Implementation of Linked List Cursor operation simulates the features Collection of structures uses array for nodes Array index is pointer new and delete operation Keep a free list new returns an element from freelist delete place the node in freelist Freelist Use cell 0 as header All nodes are free initially 0 is a NULL pointer

39 39 Cursor Implementation of Linked List If L = 5, then L represents list (A, B, E) If M = 3, then M represents list (C, D, F)

40 40 Iterator for cursor implementation of linked lists template class ListItr { public: ListItr( ) : current( 0 ) { } bool isPastEnd( ) const {return current == 0; } void advance( ){ if( !isPastEnd( ) ) current = List ::cursorSpace[ current ].next; } const Object & retrieve( ) const { if( isPastEnd( ) ) throw BadIterator( ); return List ::cursorSpace[ current ].element; } private: int current; // Current position friend class List ; ListItr( int theNode ) : current( theNode ) { } };

41 41 Class skeleton for cursor-based List template class ListItr; // Incomplete declaration. template class List { public: List( ); List( const List & rhs ); ~List( ); bool isEmpty( ) const; void makeEmpty( ); ListItr zeroth( ) const; ListItr first( ) const; void insert( const Object & x, const ListItr & p ); ListItr find( const Object & x ) const; ListItr findPrevious( const Object & x ) const; void remove( const Object & x );

42 42 Class skeleton for cursor-based List public: struct CursorNode { CursorNode( ) : next( 0 ) { } private: CursorNode( const Object & theElement, int n ) : element( theElement ), next( n ) {} Object element; int next; friend class List ; friend class ListItr ; }; const List & operator=( const List & rhs );

43 43 Class skeleton for cursor-based List private: int header; static vector cursorSpace; static void initializeCursorSpace( ); static int alloc( ); static void free( int p ); friend class ListItr ; };

44 44 cursorSpace initialization /* Routine to initialize the cursorSpace. */ template void List ::initializeCursorSpace( ) { static int cursorSpaceIsInitialized = false; if( !cursorSpaceIsInitialized ) { cursorSpace.resize( 100 ); for( int i = 0; i < cursorSpace.size( ); i++ ) cursorSpace[ i ].next = i + 1; cursorSpace[ cursorSpace.size( ) - 1 ].next = 0; cursorSpaceIsInitialized = true; }

45 45 Routines : alloc and free /* Allocate a CursorNode template int List ::alloc( ) { int p = cursorSpace[ 0 ].next; cursorSpace[ 0 ].next = cursorSpace[ p ].next; return p; } /* Free a CursorNode template void List ::free( int p ) { cursorSpace[ p ].next = cursorSpace[ 0 ].next; cursorSpace[ 0 ].next = p; }

46 46 Short routines for cursor-based lists /* Construct the list template List ::List( ) { initializeCursorSpace( ); header = alloc( ); cursorSpace[ header ].next = 0; } /* Destroy the list template List ::~List( ) { makeEmpty( ); free( header ); }

47 47 Short routines for cursor-based lists /* Test if the list is logically empty. return true if empty template bool List ::isEmpty( ) const { return cursorSpace[ header ].next == 0; } /* Return an iterator representing the first node in the list. This operation is valid for empty lists. template ListItr List ::first( ) const { return ListItr ( cursorSpace[ header ].next ); }

48 48 find routine - cursor implementation /*Return iterator corresponding to the first node containing an item x. Iterator isPastEnd if item is not found. template ListItr List ::find( const Object & x ) const { int itr = cursorSpace[ header ].next; while( itr != 0 && cursorSpace[ itr ].element != x ) itr = cursorSpace[ itr ].next; return ListItr ( itr ); }

49 49 insertion routine-cursor implementation /* Insert item x after p. template void List ::insert(const Object & x,const ListItr & p) { if( p.current != 0 ) { int pos = p.current; int tmp = alloc( ); cursorSpace[ tmp ] = CursorNode( x, cursorSpace[ pos ].next ); cursorSpace[ pos ].next = tmp; }

50 50 deletion routine - cursor implementation /* Remove the first occurrence of an item x. template void List ::remove( const Object & x ) { ListItr p = findPrevious( x ); int pos = p.current; if( cursorSpace[ pos ].next != 0 ) { int tmp = cursorSpace[ pos ].next; cursorSpace[ pos ].next = cursorSpace[ tmp ].next; free ( tmp ); }


Download ppt "DATA STRUCTURES AND ALGORITHMS Lecture Notes 3 Prepared by İnanç TAHRALI."

Similar presentations


Ads by Google