1. 1 Chapter 16 Linked Structures Dale/Weems/Headington

2. 2 Chapter 16 Topics l Meaning of a Linked List l Meaning of a Dynamic Linked List l Traversal, Insertion and Deletion of Elements in a Dynamic Linked List l Specification of a Dynamic Linked Sorted List l Insertion and Deletion of Elements in a Dynamic Linked Sorted List

3. 3 What is a List? l A list is a varying-length, linear collection of homogeneous elements. l linear means each list element (except the first) has a unique predecessor, and each element (except the last) has a unique successor

4. 4 To implement the List ADT The programmer must 1) choose a concrete data representation for the list, and 2) implement the list operations

5. Array-Based Sorted List Operations Transformers n Insert n Delete Observers n IsEmpty n IsFull n Length n IsPresent n Print change state observe state 5

6. 6 Array-based class SortedList IsFull Length IsPresent Delete IsEmpty Insert Print Private data: length data [ 0 ] [ 1 ] [ 2 ] [MAX_LENGTH-1] SortedList

7. 7 // SPECIFICATION FILE ARRAY-BASED SORTED LIST( slist.h ) const int MAX_LENGTH = 50 ; typedef int ItemType ; class SortedList { public : // public member functions SortedList ( ) ;// constructor bool IsEmpty ( ) const ; bool IsFull ( ) const ; int Length ( ) const ; // returns length of list void Insert ( ItemType item ) ; void Delete ( ItemType item ) ; bool IsPresent( ItemType item ) const ; void Print ( ) ; private :// private data members int length ; // number of values currently stored ItemTypedata[MAX_LENGTH] ; void BinSearch ( ItemType item, bool& found, int& position ) const ; } ; 7

8. 8 How to Implement a List l use a built-in array stored in contiguous memory locations, implementing operations Insert and Delete by moving list items around in the array, as needed l use a linked list (to avoid excessive data movement from insertions and deletions) not necessarily stored in contiguous memory locations

9. 9 Implementation Possibilities for a List ADT List Linked list Built-in array Built-in dynamic data and pointers Built-in array of structs

10. 10 A Linked List l a linked list is a list in which the order of the components is determined by an explicit link member in each node the nodes are struct s--each node contains a component member and also a link member that gives the location of the next node in the list head ‘X’ ‘C’ ‘L’

11. 11 Dynamic Linked List head “Ted” “Irv” “Lee” l in a dynamic linked list, nodes are linked together by pointers, and an external pointer (or head pointer) points to the first node in the list

12. 12 Nodes can be located anywhere in memory l the link member holds the memory address of the next node in the list head 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000

13. 13 // Type DECLARATIONS struct NodeType { char info; NodeType* link; } typedef NodeType* NodePtr; // Variable DECLARATIONS NodePtr head; NodePtr ptr; 13 Declarations for a Dynamic Linked List. info. link ‘A’ 6000

14. 14 Pointer Dereferencing and Member Selection. info. link ‘A’ 6000 ptr. info. link ‘A’ 6000 *ptr ptr. info. link (*ptr).info ptr->info ‘A’ 6000

15. 15 ptr is a pointer to a node. info. link ‘A’ 6000 ptr

16. 16 *ptr is the entire node pointed to by ptr ptr. info. link ‘A’ 6000 *ptr

17. 17 ptr->info is a node member ptr. info. link ptr->info (*ptr).info // equivalent ‘A’ 6000

18. 18 ptr->link is a node member ptr. info. link ptr->link (*ptr).link // equivalent ‘A’ 6000

19. 19 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head

20. 20 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 3000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

21. 21 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 3000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

22. 22 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 3000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

23. 23 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 5000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

24. 24 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 5000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

25. 25 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 5000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

26. 26 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

27. 27 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

28. 28 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

29. 29 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr NULL 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

30. 30 //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout info ; // Or, do something else with node *ptr ptr = ptr->link ; } ptr NULL 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 3000 5000 2000 head Traversing a Dynamic Linked List

31. Using Operator new If memory is available in an area called the free store (or heap), operator new allocates the requested object, and returns a pointer to the memory allocated. The dynamically allocated object exists until the delete operator destroys it. 31

32. 32 Inserting a Node at the Front of a List char item = ‘B’; NodePtr location; location = new NodeType; location->info = item; location->link = head; head = location; head ‘X’ ‘C’ ‘L’ ‘B’ item

33. 33 Inserting a Node at the Front of a List char item = ‘B’; NodePtr location; location = new NodeType; location->info = item; location->link = head; head = location; head ‘X’ ‘C’ ‘L’ ‘B’ item location

34. 34 Inserting a Node at the Front of a List char item = ‘B’; NodePtr location; location = new NodeType; location->info = item; location->link = head; head = location; head ‘X’ ‘C’ ‘L’ ‘B’ item location

35. 35 Inserting a Node at the Front of a List char item = ‘B’; NodePtr location; location = new NodeType; location->info = item; location->link = head; head = location; head ‘X’ ‘C’ ‘L’ ‘B’ item location ‘B’

36. 36 Inserting a Node at the Front of a List char item = ‘B’; NodePtr location; location = new NodeType; location->info = item; location->link = head; head = location; head ‘X’ ‘C’ ‘L’ ‘B’ item location ‘B’

37. 37 Inserting a Node at the Front of a List char item = ‘B’; NodePtr location; location = new NodeType; location->info = item; location->link = head; head = location; head ‘X’ ‘C’ ‘L’ ‘B’ item location ‘B’

38. The object currently pointed to by the pointer is deallocated, and the pointer is considered undefined. The object’s memory is returned to the free store. Using Operator delete 38

39. 39 Deleting the First Node from the List NodePtr tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; head item ‘B’ ‘X’ ‘C’ ‘L’ tempPtr

40. 40 Deleting the First Node from the List NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; head item ‘B’ ‘X’ ‘C’ ‘L’ tempPtr ‘B’

41. 41 Deleting the First Node from the List NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; head item ‘B’ ‘X’ ‘C’ ‘L’ tempPtr ‘B’

42. 42 Deleting the First Node from the List NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; head item ‘B’ ‘X’ ‘C’ ‘L’ tempPtr ‘B’

43. 43 Deleting the First Node from the List NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; head item ‘X’ ‘C’ ‘L’ tempPtr ‘B’

44. 44 What is a List? l a list is a varying-length, linear collection of homogeneous elements l linear means each list element (except the first) has a unique predecessor, and each element (except the last) has a unique successor

45. ADT SortedList2 Operations Transformers n InsertTop n Insert n DeleteTop n Delete Observers n Print n IsEmpty change state observe state 45

46. 46 // SPECIFICATION FILE DYNAMIC-LINKED SORTED LIST( slist2.h ) typedef int ItemType ; // Type of each component // is simple type or string type struct NodeType { ItemType item ;// Pointer to person’s name NodeType* link ;// link to next node in list } ; typedef NodeType* NodePtr; 46 struct NodeType

47. 47 // SPECIFICATION FILE DYNAMIC-LINKED SORTED LIST( slist2.h ) class SortedList2 { public : bool IsEmpty ( ) const ; void Print ( ) const ; void InsertTop ( /* in */ ItemType item ) ; void Insert ( /* in */ ItemType item ) ; void DeleteTop ( /* out */ ItemType& item ) ; void Delete ( /* in */ ItemType item ); SortedList2 ( ) ;// Constructor ~SortedList2 ( ) ;// Destructor SortedList2 ( const SortedList2& otherList ) ; // Copy-constructor private : NodeType* head; } ; 47

48. 48 class SortedList2 Print ~SortedList2 Insert InsertTop SortedList2 IsEmpty Delete ‘C’ ‘L’ ‘X’ Private data: head DeleteTop

49. 49 Insert Algorithm l what will be the algorithm to Insert an item into its proper place in a sorted linked list? l that is, for a linked list whose elements are maintained in ascending order?

50. 50 Insert algorithm for SortedList2 l find proper position for the new element in the sorted list using two pointers prevPtr and currPtr, where prevPtr trails behind currPtr l obtain a node for insertion and place item in it l insert the node by adjusting pointers

51. 51 Implementing SortedList2 Member Function Insert // DYNAMIC LINKED LIST IMPLEMENTATION (slist2.cpp) void SortedList2 :: Insert ( /* in */ ItemType item ) // PRE: item is assigned && List components in ascending order // POST: item is in List && List components in ascending order {. }

52. 52 Inserting ‘S’ into a Sorted List ‘C’ ‘L’ ‘X’ Private data: head prevPtr currPtr

53. 53 Finding Proper Position for ‘S’ ‘C’ ‘L’ ‘X’ Private data: head prevPtr currPtr NULL

54. 54 ‘C’ ‘L’ ‘X’ Private data: head prevPtr currPtr Finding Proper Position for ‘S’

55. 55 ‘C’ ‘L’ ‘X’ Private data: head prevPtr currPtr Finding Proper Position for ‘S’

56. 56 ‘C’ ‘L’ ‘X’ Private data: head prevPtr currPtr Inserting ‘S’ into Proper Position ‘S’

57. 57 // IMPLEMENTATION DYNAMIC-LINKED SORTED LIST (slist2.cpp) SortedList2 ::SortedList2 ( ) // Constructor // Post: head == NULL { head = NULL ; } SortedList2 :: ~SortedList2 ( ) // Destructor // Post: All linked nodes deallocated { ItemType temp ; // keep deleting top node while ( !IsEmpty ) DeleteTop ( temp ); } 57

58. 58 void SortedList2 :: Insert( /* in */ ItemType item ) // Pre: item is assigned && list components in ascending order // Post:new node containing item is in its proper place // && list components in ascending order { NodePtr currPtr ; NodePtr prevPtr ; NodePtr location ; location = new NodeType ; newNodePtr->link = item ; prevPtr = NULL ; currPtr = head ; while ( currPtr != NULL && item > currPtr->info ) {prevPtr = currPtr ; // advance both pointers currPtr = currPtr->link ; } location->link = currPtr ; // insert new node here if ( prevPtr == NULL ) head = location ; else prevPtr->link = location ; } 58

59. 59 void SortedList2 :: DeleteTop ( /* out */ ItemType& item ) // Pre: list is not empty && list elements in ascending order // Post: item == element of first list node @ entry // && node containing item is no longer in linked list // && list elements in ascending order { NodePtr tempPtr = head ; // obtain item and advance head item = head->info ; head = head->link ; delete tempPtr ; } 59

60. 60 void SortedList2 :: Delete ( /* in */ ItemType item ) // Pre: list is not empty && list elements in ascending order // && item == component member of some list node // Post: item == element of first list node @ entry // && node containing first occurrence of item is no longer // in linked list && list elements in ascending order { NodePtr delPtr ; NodePtr currPtr ;// Is item in first node? if ( item == head->info ) { delPtr = head ;// If so, delete first node head = head->link ; } else {// search for item in rest of list currPtr = head ; while ( currPtr->link->info != item ) currPtr = currPtr->link ; delPtr = currPtr->link ; currPtr->link = currPtr->link->link ; } delete delPtr ; } 60

61. 61 class SortedList2 Print ~SortedList2 Insert InsertTop SortedList2 IsEmpty Delete ‘C’ ‘L’ ‘X’ Private data: head DeleteTop