lecture07 the linked-list_as_a_data_structure_v3

1

Chapter 7The Linked List as a

Data Structure

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.

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…

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.

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

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.

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.

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

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.

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.

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

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.

13

Advantages ofApproach 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.

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.

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 obj1obj1 = ptr->info;

• The retrieve function returns true (indicating a find) and obj1 is returned by reference parameter.

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

17

Find and ReplaceFunctions

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

18

LinkedListImplementation

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

19

LinkedList.hpp

1 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( ) { … }

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 };

21

Constructor & Destructor

2 LinkedList( )3 {4 start = current = NULL;5 }67 ~LinkedList( )8 {9 makeEmpty( );10 }

22

insert

30 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;37 }

Inserting at the beginning of the linked list.

23

first

49 bool first( T & listEl )50 {51 if ( start == NULL ) 52 return false;5354 current = start;55 listEl = start->info;56 return true;57 }

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 }

25

find73 bool find( const T & element )75 {76 T item;77 if ( !first( item ) )78 return false;79 do if ( item == element ) 80 return true;81 while ( getNext( item ) );8283 return false;84 }

Overloaded operator if T is a struct object

26

retrieve

87 bool retrieve( T & element )88 {89 if ( !find( element ) )90 return false;91 element = current->info;92 return true;93 }

27

replace

96 bool replace( const T & newElement ) 97 {98 if ( current == NULL )99 return false;100 current->info = newElement;101 return true;102 }

28

remove105 bool remove( T & element )106 {107 current = NULL;108 if ( start == NULL )109 return false;110 Node<T> *ptr = start;111 if ( ptr->info == element ) {112 start = start->next;113 delete ptr;114 return true;115 }

We need to keep ptr one node in front of the node to remove, so the first node is a special case.

remove continued…

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 }

30

isEmpty

132 bool isEmpty( ) const133 {134 return start == NULL;135 }

31

makeEmpty

137 void makeEmpty( ) 138 {139 while ( start != NULL ) {140 current = start;141 start = start->next;142 delete current;143 }144145 current = NULL;146 }

Reference

• Childs, J. S. (2008). The Linked List as a Data Structure. C++ Classes and Data Structures. Prentice Hall.

32