1. C++ Programming: From Problem Analysis to Program Design, Second Edition Chapter 17: Linked Lists

2. C++ Programming: From Problem Analysis to Program Design, Second Edition2 Objectives In this chapter you will: Learn about linked lists Become aware of the basic properties of linked lists Explore the insertion and deletion operations on linked lists Discover how to build and manipulate a linked list Learn how to construct a doubly linked list

3. C++ Programming: From Problem Analysis to Program Design, Second Edition3 Introduction Data can be organized and processed sequentially using an array, called a sequential list Problems with an array −Array size is fixed −Unsorted array: searching for an item is slow −Sorted array: insertion and deletion is slow

4. C++ Programming: From Problem Analysis to Program Design, Second Edition4 Linked Lists Linked list: collection of components (nodes) Every node (except last) has address of next node Every node has two components Address of the first node of the list is stored in a separate location, called head or first

5. C++ Programming: From Problem Analysis to Program Design, Second Edition5 A Linked List 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’

6. C++ Programming: From Problem Analysis to Program Design, Second Edition6 Dynamic Linked List head “Ted” “Irv” “Lee” 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

7. C++ Programming: From Problem Analysis to Program Design, Second Edition7 Nodes can be located anywhere in memory 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

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

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

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

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

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

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

14. C++ Programming: From Problem Analysis to Program Design, Second Edition14 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

15. C++ Programming: From Problem Analysis to Program Design, Second Edition15 //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

16. C++ Programming: From Problem Analysis to Program Design, Second Edition16 //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

17. C++ Programming: From Problem Analysis to Program Design, Second Edition17 //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

18. C++ Programming: From Problem Analysis to Program Design, Second Edition18 //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

19. C++ Programming: From Problem Analysis to Program Design, Second Edition19 //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

20. C++ Programming: From Problem Analysis to Program Design, Second Edition20 //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

21. C++ Programming: From Problem Analysis to Program Design, Second Edition21 //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

22. C++ Programming: From Problem Analysis to Program Design, Second Edition22 //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

23. C++ Programming: From Problem Analysis to Program Design, Second Edition23 //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

24. C++ Programming: From Problem Analysis to Program Design, Second Edition24 //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

25. C++ Programming: From Problem Analysis to Program Design, Second Edition25 //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

26. 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. 26

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

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

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

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

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

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

33. 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 33

34. 34 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

35. 35 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’

36. 36 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’

37. 37 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’

38. 38 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’

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

40. 40 // SPECIFICATION FILE DYNAMIC-LINKED SORTED LIST( slist2.h ) struct NodeType { char item ;// Data (char to keep example simple) NodeType* link ;// link to next node in list } ; 40 struct NodeType

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

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

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

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

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

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

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

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

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

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

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

52. 52 void SortedList2 :: Insert( /* in */ char 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 { NodeType* currPtr ; NodeType* prevPtr ; NodeType* location ; location = new NodeType ; location->info = 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 ; } 52

53. 53 void SortedList2 :: DeleteTop ( /* out */ char& 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 { NodeType* tempPtr = head ; // obtain item and advance head item = head->info ; head = head->link ; delete tempPtr ; } 53

54. 54 void SortedList2 :: Delete ( /* in */ char 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 { NodeType* delPtr ; NodeType* 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 ; } 54

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

56. C++ Programming: From Problem Analysis to Program Design, Second Edition56 Another Linked List Linked list above has four nodes Address of first node is stored in head Each node has two components: −Info: stores the info −Link: stores address of the next node

58. C++ Programming: From Problem Analysis to Program Design, Second Edition58 Doubly Linked Lists Doubly linked list: every node has next and back pointers Can be traversed in either direction

59. C++ Programming: From Problem Analysis to Program Design, Second Edition59 Struct for Doubly Linked List struct NodeType { int item ;// Data NodeType* next;// link to next node in list NodeType* back; // link to previous node in list } ;

60. C++ Programming: From Problem Analysis to Program Design, Second Edition60 Delete a Node Consider the list shown in the figure below

62. C++ Programming: From Problem Analysis to Program Design, Second Edition62 Programming Example A new video store in your neighborhood is about to open However, it does not have a program to keep track of its videos and customers The store managers want someone to write a program for their system so that the video store can operate

63. C++ Programming: From Problem Analysis to Program Design, Second Edition63 Programming Example (continued) The program should be able to perform the following operations: −Rent a video; that is, check out a video −Return, or check in, a video −Create a list of videos owned by the store −Show the details of a particular video −Print a list of all videos in the store −Check whether a particular video is in the store −Maintain a customer database −Print list of all videos rented by each customer

64. C++ Programming: From Problem Analysis to Program Design, Second Edition64 Programming Example (continued) There are two major components of the video store: −A video −A customer You need to maintain two lists: 1.A list of all videos in the store 2.A list of all customers of the store

65. C++ Programming: From Problem Analysis to Program Design, Second Edition65 Part 1: Video Component (continued) The common things associated with a video are: −Name of the movie −Names of the stars −Name of the producer −Name of the director −Name of the production company −Number of copies in store

68. C++ Programming: From Problem Analysis to Program Design, Second Edition68 Video List This program requires us to −Maintain a list of all videos in the store −Add a new video to our list Use a linked list to create a list of videos

71. C++ Programming: From Problem Analysis to Program Design, Second Edition71 Part 2: Customer Component Primary characteristics of a customer: −First name −Last name −Account number −List of rented videos

73. C++ Programming: From Problem Analysis to Program Design, Second Edition73 Basic Operations Basic operations on personType: −Print the name −Set the name −Show the first name −Show the last name

74. C++ Programming: From Problem Analysis to Program Design, Second Edition74 Basic Operations (continued) Basic operations on an object of the type customerType are: −Print name, account #, and number of rentals −Set name, account #, and number of rentals −Rent a video, add video to the list −Return a video, delete video from the list −Show account #

75. C++ Programming: From Problem Analysis to Program Design, Second Edition75 Main Program The data in the input file is in the form: video title movie star1 movie star2 movie producer movie director movie production co. number of copies.

76. C++ Programming: From Problem Analysis to Program Design, Second Edition76 Algorithm of the Main Function Open the input file, exit if not found createVideoList: create the list of videos displayMenu: show the menu While not done, perform various tasks

77. C++ Programming: From Problem Analysis to Program Design, Second Edition77 CreateVideoList 1.Read data and store in a video object 2.Insert video in list 3.Repeat steps 1 and 2 for each video in file

78. C++ Programming: From Problem Analysis to Program Design, Second Edition78 displayMenu Select one of the following 1.Check whether a particular video is in the store 2.Check out a video 3.Check in a video 4.Check whether a particular video is in the store 5.Print the titles of all videos 6.Print a list of all videos 9.Exit

79. C++ Programming: From Problem Analysis to Program Design, Second Edition79 Summary A linked list is a list of items (nodes) Order of the nodes is determined by the address, called a link, stored in each node The pointer to a linked list is called head or first A linked list is a dynamic data structure The list length is the number of nodes

80. C++ Programming: From Problem Analysis to Program Design, Second Edition80 Summary Insertion and deletion does not require data movement; only the pointers are adjusted A (single) linked list is traversed in only one direction Search of a linked list is sequential The head pointer is fixed on first node Traverse: use a pointer other than head

81. C++ Programming: From Problem Analysis to Program Design, Second Edition81 Summary Doubly linked list −Every node has two links: next and previous −Can be traversed in either direction −Item insertion and deletion require the adjustment of two pointers in a node