Upcoming SlideShare
×

268

Published on

0 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

• Be the first to like this

Views
Total Views
268
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
3
0
Likes
0
Embeds 0
No embeds

No notes for slide

1. 1. Chapter 7The Linked List as a Data Structure 1
2. 2. The List ADT• A list is a list of elements.• The list of elements consist of the data acted upon by list operations.• A current position (or active position) in the list is also acted upon by list operations. 2
3. 3. List ADT Operations• insert, to insert a new item into the list; there is no current position after an insertion.• an iterator, for retrieving (by copy instead of removal) each item from the list, one at a time; at any particular moment when an item is retrieved, that item becomes the current position in the list.• find, to determine whether or not a certain item exists in a list; if the item exists, it becomes the current position.• retrieve, to retrieve (by copy instead of removal) a certain item; that item becomes the current position.• more… 3
4. 4. List ADT Operations (cont.)• replace, to replace the item at the current position with another item; the current position remains unchanged.• remove, to remove an item from a list; there is no current position after a removal.• an operation to determine whether or not the list is empty; the current position is unchanged.• an operation to empty out the list; the current position is lost. 4
5. 5. Retrieving Elements• When the client needs to retrieve an element in the list, the main practical reason is because it contains information that the client doesn’t have.• Yet, the clients must know something about it; otherwise, they would not be able to tell the List object to look for it.• The clients know about the key... 5
6. 6. Keys• A key is a value that uniquely identifies an object – If objects are people, a good key would be the SSN – books – ISBN key – parts – part number key• The elements in a list ADT are usually objects – the key is just a single data member of the object. 6
7. 7. An Example• A customer of an insurance company has a problem with the amount paid by the insurance company for an operation.• The customer calls the insurance company.• The insurance company asks the customer for the claim number (the key).• The customer provides the claim number. 7
8. 8. An Example (cont.)• The insurance company representative types the claim number (key) into the computer.• The claim number is typed into a program which is using one or more data structures.• The retrieve function of a data structure is called, passing in the claim number (key). 8
9. 9. An Example (cont.)• The retrieve function searches the data structure for the object that has the key.• The retrieve function finds the object and returns the object.• All the data in the object is now provided to the main program.• The main program shows all the data on the screen. 9
10. 10. An Example (cont.)• The insurance company representative looks at the data.• The insurance company representative can now see what the customer is complaining about. 10
11. 11. List Implementation• In C++, lists can be implemented with arrays or linked lists.• Recall 2 advantages of linked lists – conserve memory for large objects (such as objects with keys). – can easily remove an element from the middle.• So, we’ll focus on using the linked list.• Instead of saying “linked-list implementation of a list”, we’ll just say “linked list”. 11
12. 12. Retrieve Function Implementation• How should we pass a key into the retrieve function and return the object?• Approach 1: Pass in a key as a parameter and pass in an object as a reference parameter (to return the object result).• Approach 2: Pass in an object by reference which has its key set to the key to search for; when the object is found in the linked list, it is assigned to the object passed in by reference. 12
13. 13. Advantages of Approach 2• The client must declare an object, which will hold the data retrieved from the linked list. – approach 2 relieves the client of also having to declare a key; a key is already in the object.• If approach 1 is used, two T’s are needed (say, T1 and T2) for the object type and the key type• approach 2 will also be used for the find and remove functions. 13
14. 14. The Retrieval Process• An object is created in the main program.• The representative asks the customer for the key.• The representative types in the key.• The object’s data member is set to the key value; no other data members in the object are set.• The object (let’s say obj1) is passed into the retrieve function by reference. 14
15. 15. The Retrieval Process (cont.)• The struct for obj1 has an overloaded operator, used by the retrieve function for finding the object with the key: Example: if ( obj1 == ptr->info ) // found• The other information is placed in obj1 obj1 = ptr->info;• The retrieve function returns true (indicating a find) and obj1 is returned by reference parameter. 15
16. 16. The Iterator• first – returns the first element in the linked list.• getNext – returns the next element in the linked list, after the first function call or previous getNext function call – Implemented by maintaining a current pointer in the private section. – The current pointer is advanced every time getNext is called. – Returns false when the client tries to get an element beyond the end of the list (otherwise returns true). 16
17. 17. Find and Replace Functions• find – returns true only if an element with the key was found – the element itself is not returned.• replace – replaces the element at the current position with the element passed in – find and replace functions will often be used together. 17
18. 18. LinkedList Implementation• A general linked list is more involved than the linked list queue or the linked list stack.• The client must be able to access, change, or remove any element in the linked list at any time.• It should be implemented to handle key- oriented types of objects, but also be general enough to handle other objects without keys, like strings. 18
19. 19. LinkedList.hpp1 template <template T>2 struct Node {3 T info;4 Node<T> *next;5 };67 template <template T>8 class LinkedList9 {10 public:11 LinkedList( ) { … } 19
20. 20. LinkedList.hpp (cont.)15 ~LinkedList( ) { … }16 void insert( const T & element ) { … }17 bool first( T & listEl ) { … }18 inline bool getNext( T & listEl ) { … }19 bool find ( const T & element ) { … }20 bool retrieve( T & element ) { … }21 bool replace( const T & newElement ) { … }22 bool remove( T & element ) { … }23 bool isEmpty( ) const { … }24 void makeEmpty( ) { … }25 private:26 Node<T> *start;27 Node<T> *current;28 }; 20
21. 21. Constructor & Destructor2 LinkedList( )3 {4 start = current = NULL;5 }67 ~LinkedList( )8 {9 makeEmpty( );10 } 21
22. 22. insert30 void insert( const T & element )31 {32 current = NULL;33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 newNode->next = start;36 start = newNode; Inserting at the37 } beginning of the linked list. 22
23. 23. first49 bool first( T & listEl )50 {51 if ( start == NULL )52 return false;5354 current = start;55 listEl = start->info;56 return true;57 } 23
24. 24. getNext60 bool getNext( T & listEl )61 {62 if ( current == NULL )63 return false;64 if ( current->next == NULL ) {65 current = NULL;66 return false;67 }68 current = current->next;69 listEl = current->info;70 return true;71 } 24
25. 25. find73 bool find( const T & element )75 {76 T item;77 if ( !first( item ) ) Overloaded78 return false; operator if T is79 do if ( item == element ) a struct object80 return true;81 while ( getNext( item ) );8283 return false;84 } 25
26. 26. retrieve87 bool retrieve( T & element )88 {89 if ( !find( element ) )90 return false;91 element = current->info;92 return true;93 } 26
27. 27. replace96 bool replace( const T & newElement )97 {98 if ( current == NULL )99 return false;100 current->info = newElement;101 return true;102 } 27
28. 28. remove105 bool remove( T & element )106 {107 current = NULL;108 if ( start == NULL )109 return false; We need to keep110 Node<T> *ptr = start; ptr one node in111 if ( ptr->info == element ) { front of the node to112 start = start->next; remove, so the first113 delete ptr; node is a special114 return true; case.115 } remove continued… 28
29. 29. remove (cont.)117 while ( ptr->next != NULL ) {118 if ( ptr->next->info == element ) {119 Node<T> *tempPtr = ptr->next;120 ptr->next = tempPtr->next;121 delete tempPtr;122 return true;123 }124 ptr = ptr->next;125 }126127 return false;128 } 29
30. 30. isEmpty132 bool isEmpty( ) const133 {134 return start == NULL;135 } 30
31. 31. makeEmpty137 void makeEmpty( )138 {139 while ( start != NULL ) {140 current = start;141 start = start->next;142 delete current;143 }144145 current = NULL;146 } 31
32. 32. Reference• Childs, J. S. (2008). The Linked List as a Data Structure. C++ Classes and Data Structures. Prentice Hall. 32
1. #### A particular slide catching your eye?

Clipping is a handy way to collect important slides you want to go back to later.