1 / 35

CSS342: Linked Lists

CSS342: Linked Lists. Professor: Munehiro Fukuda. Topics. Basic concepts of linked lists Implementations Special implementations Applications. Basic Concepts. 45. 76. 84. Linked List. header. 20. 51. NULL. X. template<class Object> struct LListNode { Object item;

niel
Download Presentation

CSS342: Linked Lists

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CSS342: Linked Lists Professor: Munehiro Fukuda CSS342: Linked Lists

  2. Topics • Basic concepts of linked lists • Implementations • Special implementations • Applications CSS342: Linked Lists

  3. Basic Concepts 45 76 84 Linked List header 20 51 NULL X template<class Object> struct LListNode { Object item; LListNode *next; }; template<class Object> class LList { public: LList( ); LList( const LList &rhs ); ~LList( ); bool isEmpty( ) const; void clear( ); void insert( const Object &x, int index ); // insert a new item right after the index int find( const Object &x ) const; void remove( const Object &x ); const LList &operator=( const LList &rhs ); private: LListNode<Object> *header; LListNode<Object> *findByIndex( int index ) const; LListNode<Object> *findPrevious( const Object &x ) const; }; Removed item 60 Inserted item X == 45 CSS342: Linked Lists

  4. Basic Concepts STL Class list CSS342: Linked Lists

  5. Basic Concepts STL Class listExample #include <list> #include <iostream> #include <string> using namespace std; int main( ) { list<string> facultyList; list<string>::iterator i = facultyList.begin( ); i = facultyList.insert( i, “berger” ); i = facultyList.insert( i, “cioch” ); i = facultyList.insert( i, “fukuda” ); cout << “#faculty members: “ << facultyList.size( ) << endl; for (i = facultyList.begin( ); i != facultyList.end( ); i++ ) cout <<*i << endl; } Results (= inputs are reversed): #faculty members: 3 fukuda cioch berger CSS342: Linked Lists

  6. Implementation Array-Based List Implementation • Easy implementation • Fixed list size • Necessity to shift data down to an extended space upon an insertion and to shift data up upon a deletion • What is big-O for those operations? • Find • Insert • Delete list[0] list[1] list[2] list[3] list[4] list[n] list[n-1] CSS342: Linked Lists

  7. Implementation 84 76 84 76 45 45 20 51 Merits of Linked List • Each item points to its successor • Arbitrary list size • No shift operations • Pointer operations required NULL 20 51 NULL Deleted item 60 Inserted item CSS342: Linked Lists

  8. Implementation item item item item next next next next Pointer-Based Linked Listprivate data items item • List element struct LListNode { Object item; Node *next; } • Header pointer LListNode *header; If header == NULL, list is empty. Object* Object Object LListNode* LListNode header NULL head NULL CSS342: Linked Lists

  9. Implementation NULL current cur current 76 76 51 60 insert( &Object newValue, int index)Inserting a New Node (after an Index) • Creating a new node • LListNode *newptr = new Node; • newPtr->item = newValue; • Inserting a node between nodes • newPtr->next = current->next; • current->next = newPtr; • Inserting a node at the top • newPtr->next = head; • header = newptr; • Should we really distinguish these two cases? header 51 NULL 60 newValue index header NULL Current actually cannot point to header! CSS342: Linked Lists

  10. Implementation item item item next next next X new Value next insert( )Node Definition Revisited dummy header 0th element header NULL • List element struct LListNode { Object item; Node *next; } • Header pointer and node // adding a dummy header node LListNode *header = new Node; header->next = null; If head->next == NULL, list is empty. • Node Insertion • LListNode *newptr = new Node; • newPtr->item = newValue; • newPtr->next = current->next; • current->next = newPtr; dummy header 0th element 1st node header NULL current newptr CSS342: Linked Lists

  11. Implementation NULL 45 76 remove( const Object &x )Removing a Given Node • Stop the current pointer at the node previous to a deleted node (with findPrevious( )) • Memorize the node to remove LListNode *deletedNode = current->next; • Remove this node current->next = current->next->next; • Deallocating the node delete deletedNode; x dummy header 20 NULL current Node to be deleted CSS342: Linked Lists

  12. Implementation header 51 60 p p p int find( const Object &x )Finding a Position That Includes X for (LListNode *p = header->next; p != NULL && p->element != x; p = p->next ); X dummy NULL Iteration 1: Exited from here Iteration 2: Iteration 3: CSS342: Linked Lists

  13. Implementation header 60 51 p p p LListNode<Object> *findByIndex( int index )Finding a Position by an Index template<class Object> LListNode<Object> *LList<Object>::findByIndex( int index ) const { if ( index < 0 ) return NULL; LListNode<Object> *p = header; for ( int i = 0; p != NULL; p = p->next, i++ ) if ( i == index ) break; return p; } index = 2 dummy NULL index 0: Note: index 0 is a dummy index 1: index 2: Exited from here CSS342: Linked Lists

  14. Implementation header 55 51 60 p p p p LListNode<Object> *findPrevious( Object &x )Finding the Node Previous to the One to Be Deleted for (LListNode *p = header; p->next != NULL && p->next->item != x; p = p->next); X dummy NULL Iteration 1: Iteration 2: Iteration 3: Exitted from here Iteration 4: CSS342: Linked Lists

  15. Implementation head 51 45 51 51 20 45 ~LList( )Destructor template<class Object> LList<Object>::~LList( ) { clear( ); delete header; } template<class Object> void LList<Object>::clear( ) { while ( !isEmpty( ) ) { LListNode<Object> *node = findByIndex( 1 ); remove( node->item ); } } • Deallocate all pointer variables NULL findByIndex(1) head NULL findByIndex(1) head NULL findByIndex(1) CSS342: Linked Lists

  16. Implementation NULL copy of header header header 20 45 51 76 20 45 76 20 45 51 76 51 NULL copy of header NULL LList( const LList &rhs )Copy Constructor • Implicit calledupon passing, returning, and assigning an object. • Shallow copy: C++ and Java’s operator= copies an object’s data members. • Deep copy: Java’s clone( ) copies all traversable pointer variables. CSS342: Linked Lists

  17. Implementation dummy rhs NULL copy copy copy dummy this copy of header NULL index 0 header 51 76 51 45 45 76 LList( const LList &rhs )Copy Constructor template<class Object> const LList<Object> &LList<Object>::operator=( const LList &rhs ) { if ( this != &rhs ) {// why do we have to check ? clear( );// why do we have to call clear( )? int index; LListNode<Object> *rnode; for ( index = 0, rnode = rhs.header->next; rnode != NULL; rnode = rnode->next, ++index ) insert( rnode->item, index );// insert rnode’s item after index } return *this; } template<class Object> LList<Object>::LList( const LList &rhs ) { header = new LListNode<Object>; header->next = NULL; *this = rhs; } CSS342: Linked Lists

  18. Implementation Entire Implementation #ifndef _LLIST_CPP_ #define _LLIST_CPP_ #include <iostream> using namespace std; template<class Object> LList<Object>::LList( ) { header = new LListNode<Object>; header->next = NULL; } template<class Object> LList<Object>::LList( const LList &rhs ) { header = new LListNode<Object>; header->next = NULL; *this = rhs; } template<class Object> LList<Object>::~LList( ) { clear( ); delete header; } template<class Object> bool LList<Object>::isEmpty( ) const { return header->next == NULL; } template<class Object> void LList<Object>::clear( ) { while ( !isEmpty( ) ) { LListNode<Object> *node = findByIndex( 1 ); remove( node->item ); } } template<class Object> void LList<Object>::insert( const Object &x, int index ){ LListNode<Object> *current = findByIndex( index ); LListNode<Object> *newPtr = new LListNode<Object>; newPtr->item = x; newPtr->next = current->next; current->next = newPtr; } template<class Object> int LList<Object>::find( const Object &x ) const { LListNode<Object> *p = header->header; int i = 0; for ( ; p != NULL && p->item != x; p = p->next, ++i ); return ( p == NULL ) ? -1 : i; } 2/4 1/4 CSS342: Linked Lists

  19. Implementation Entire Implementation (Cont’d) template<class Object> void LList<Object>::remove( const Object &x ) { LListNode<Object> *current = findPrevious( x ); if ( current == NULL ) return; LListNode<Object> *deletedNode = current->next; current->next = current->next->next; delete deletedNode; } template<class Object> const LList<Object> &LList<Object>::operator=( const LList &rhs ) { if ( this != &rhs ) { clear( ); int index; LListNode<Object> *rnode; for ( index = 0, rnode = rhs.header->next; rnode != NULL; rnode = rnode->next, ++index ) insert( rnode->item, index ); } return *this; } 3/4 CSS342: Linked Lists

  20. Implementation Entire Implementation (Cont’d) template<class Object> template<class Object> LListNode<Object> *LList<Object>::findByIndex( int index ) const { if ( index < 0 ) return NULL; LListNode<Object> *p = header; for ( int i = 0; p != NULL; p = p->next, i++ ) if ( i == index ) break; return p; } template<class Object> LListNode<Object> *LList<Object>::findPrevious( const Object &x ) const{ LListNode<Object> *p; for ( p = header; p->next != NULL && p->next->item != x; p = p->next ); return p; } #endif 4/4 CSS342: Linked Lists

  21. Implementation head 45 51 Saving a Linked List in a File ofstream outFile(filename); for (LListNode *cur = head->next; cur != NULL; cur = cur->next ) { outFile << cur->item << endl; outFile << cur->next << endl; // Must it be saved? } outFile.close( ); Cur->next, memory address has no meaning when reloaded dummy 45 51 EOF NULL Save Linked list File CSS342: Linked Lists

  22. Implementation header 20 3 4 51 NULL 2 1 Restoring a Linked List from a File LListNode *tail = header; while ( inFile >> nextItem ) { tail->next = new Node; // 1. Allocate a new node next to the tail tail = tail->next; // 2. Have the tail point to the new node tail->item = nextItem; // 3. Put the new item in the node tail->next = NULL; // 4. Set the pointer in the new node to NULL } dummy 20 45 51 EOF 45 NULL Restore Linked list File tail How about the first node? CSS342: Linked Lists

  23. Array-based: Advantages: Easy to use A good choice for a small list O(1) access time Disadvantages: space and time wasting in dynamic array Pointer-Based: Advantages: Arbitrary size No shift required Disadvantages: Necessity to allocate next O(N) access time Implementation We would like to mitigate this O(N) access time Array-Based v.s. Pointer-Based Implementation CSS342: Linked Lists

  24. Special Implementation NULL 51 head list 45 51 45 Circular Linked Lists dummy • Linear linked lists:grocery, inventory, and customer lists • Circular linked lists:login users list • Traverse in circular linked lists: LListNode *first = list; // list points the 1st dummy node LListNode *cur = first->next; while ( cur != first ) { display(cur->item); cur = cur->next; }; dummy CSS342: Linked Lists

  25. Special Implementation 45 73 51 head head 45 51 Doubly Linked Lists Single Linked Lists dummy 73 NULL To be deleted Precedent must be kept track of. Doubly Linked Lists dummy NULL NULL cur->prev->next = cur->next But pointer operations become more complicated. CSS342: Linked Lists

  26. Special Implementation 45 73 51 20 Circular doubly linked list with a dummy head node head dummy Traversing a node: cur = head->next; while (cur != head && newItem != cur->item) cur = cur->next; Deleting a node: cur->prev->next = cur->next; cur->next->prev = cur->prev CSS342: Linked Lists

  27. Special Implementation 45 73 20 Inserting a Nodebefore the current pointer (d) (a) (b) (c) cur newPtr->next = cur; // (a) newPrt->prev = cur->prev; // (b) cur->prev = newPtr; // (c) newPtr->prev->next = newPtr; // (d) CSS342: Linked Lists

  28. Special Implementation 45 73 51 51 head Move-To-Front List • int find( const Object &x ) { • Move the item found to the top. } dummy NULL NULL To the front CSS342: Linked Lists

  29. Special Implementation 45 73 51 51 head Transpose List • int find( const Object &x ) { • Swap the item with its previous item. } dummy NULL NULL swap CSS342: Linked Lists

  30. Special Implementation 31 31 31 Skip Listhttp://en.wikipedia.org/wiki/Skip_list(designed in 1990) S5 – ∞ + ∞ Search for 39 S4 – ∞ 17 + ∞ S3 – ∞ 17 25 55 + ∞ Delete 31 rand( ) % 2 = 1 S2 – ∞ 17 25 55 + ∞ rand( ) % 2 = 1 S1 – ∞ 12 17 25 55 + ∞ S0 – ∞ 12 17 20 25 39 50 55 + ∞ Insert 31 CSS342: Linked Lists

  31. Applications directory entry name start block 0 test 217 217 618 339 EOF 217 339 618 339 618 #blocks -1 FAT Single Linked List Application • File Allocation Table (FAT) • FAT has an entry for each disk block. • FAT entries rather than blocks themselves are linked. • Example: • MS-DOS and OS/2 • Merit: • Save disk block space • Faster random accesses • Demerit: • A significant number of disk head seeks CSS342: Linked Lists

  32. Applications Process ID 99 Process ID 100 Process ID 217 Process ID 105 Prog name “g++” Prog name “ps2pdf” Prog name “a.out” Prog name “emacs” CPU Registers CPU Registers CPU Registers CPU Registers Page Table Page Table Page Table Page Table File Descriptors File Descriptors File Descriptors File Descriptors Circular List Application head • Round-Robin Based Job Scheduling CSS342: Linked Lists

  33. Applications HEADER NULL string int main( ) { int a = 3, b = 5; cout << a + b << endl; } NULL Doubly Linked List Application • Line-based text editors like Unix ed CSS342: Linked Lists

  34. Applications PC PC B ? 4 v Load M M MTF List Application • Page Replacement • No more free frame • Find a victim page • Paging out M cause another page fault • Paging out H may be okay. • Algorithm to minimize page faults Proc1’s page table 0 1 2 1 H 3 v 0 1 2 3 4 5 6 7 OS Load M i 5 v OS J i D M H Process 1’s logical memory Proc2’s page table 0 1 2 3 A J 6 v B A i 2 v D E 7 v Physical memory E Process 2’s logical memory CSS342: Linked Lists

  35. Applications LRU Implementation with MTF List • Replace a least recently used page with a new page. 1. Swap in page B page B LRU page Swap out page M page A page E page J page H page D page B page M page A page E page J page H 2. Access page H 3. Swap in D again Move to Front page D page H page B page M page A page E page J Swap out CSS342: Linked Lists

More Related