1

C++ Classes and Data StructuresJeffrey S. Childs

Chapter 10The Linked List as a

Data Structure

Jeffrey S. Childs

Clarion University of PA

© 2008, Prentice Hall

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 two 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 DataType’s are needed (say, DataType1 and DataType2) 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

LinkedListImplementation (cont.)

• We won’t use a header node• Arrays of linked lists are used in other data

structures, such as HashTables and Graphs – many linked lists could be empty

• A header node would simplify code, but an empty linked list with a header node would use more memory space– a dynamic header node wouldn’t help – the LinkedList

constructor would create the header node

20

LinkedList.h

1 template <class DataType>2 struct Node {3 DataType info;4 Node<DataType> *next;5 };67 template <class DataType>8 class LinkedList9 {10 public:11 LinkedList( );12 LinkedList( const LinkedList<DataType> & aplist );

LinkedList.h continued…

21

LinkedList.h (cont.)

13 ~LinkedList( );14 LinkedList<DataType> & operator =( 15 const LinkedList<DataType> & rlist );16 void insert( const DataType & element ); 17 bool first( DataType & listEl ); 18 inline bool getNext( DataType & listEl ); 19 bool find ( const DataType & element ); 20 bool retrieve( DataType & element ); 21 bool replace( const DataType & newElement ); 22 bool remove( DataType & element ); 23 bool isEmpty( ) const; 24 void makeEmpty( );

private section next…

22

LinkedList.h (cont.)

25 private:26 Node<DataType> *start;27 Node<DataType> *current; 28 inline void deepCopy( 29 const LinkedList<DataType> & original );30 };3132 #include "LinkedList.cpp"

23

Constructor / Copy Constructor

1 template <class DataType>2 LinkedList<DataType>::LinkedList( )3 {4 start = current = NULL;5 }67 template <class DataType>8 LinkedList<DataType>::LinkedList( 9 const LinkedList<DataType> & aplist )10 {11 deepCopy( aplist );12 }

24

Destructor

13 template <class DataType>14 LinkedList<DataType>::~LinkedList( )15 {16 makeEmpty( );17 }

25

Overloaded Assignment Operator

18 template <class DataType>19 LinkedList<DataType> & LinkedList<DataType>::20 operator =( const LinkedList<DataType> & rlist )21 {22 if ( this == &rlist )23 return *this;24 makeEmpty( );25 deepCopy( rlist );26 return *this;27 }

26

insert

28 template <class DataType>29 void LinkedList<DataType>::insert( 30 const DataType & element )31 {32 current = NULL;33 Node<DataType> *newNode = new Node<DataType>;34 newNode->info = element;35 newNode->next = start;36 start = newNode;37 }

Inserting at the beginning of the linked list makes this a ( 1 ) function.

27

first

48 template <class DataType>49 bool LinkedList<DataType>::first( DataType & listEl )50 {51 if ( start == NULL ) 52 return false;5354 current = start;55 listEl = start->info;56 return true;57 }

28

getNext

58 template <class DataType>59 inline bool LinkedList<DataType>::getNext( 60 DataType & listEl )61 {62 if ( current == NULL ) 63 return false;64 if ( current->next == NULL ) {65 current = NULL;66 return false;67 }

getNext continued…

29

getNext (cont.)

68 current = current->next;69 listEl = current->info;70 return true;71 }

30

find72 template <class DataType>73 bool LinkedList<DataType>::find( 74 const DataType & element )75 {76 DataType 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 DataType is a struct object

31

find (cont.)72 template <class DataType>73 bool LinkedList<DataType>::find( 74 const DataType & element )75 {76 DataType item;77 if ( !first( item ) )78 return false;79 do if ( item == element ) 80 return true;81 while ( getNext( item ) );8283 return false;84 }

Note that this is a ( n ) function.

32

retrieve

85 template <class DataType>86 bool LinkedList<DataType>::retrieve( 87 DataType & element )88 {89 if ( !find( element ) )90 return false;91 element = current->info;92 return true;93 }

33

replace

94 template <class DataType>95 bool LinkedList<DataType>::replace( 96 const DataType & newElement ) 97 {98 if ( current == NULL )99 return false;100 current->info = newElement;101 return true;102 }

34

remove

103 template <class DataType>104 bool LinkedList<DataType>::remove( 105 DataType & element )106 {107 current = NULL;108 if ( start == NULL )109 return false;

remove continued…

35

remove (cont.)

110 Node<DataType> *ptr = start;111 if ( ptr->info == element ) {112 element = ptr->info;113 start = start->next;114 delete ptr;115 return true;116 }

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

remove continued…

36

remove (cont.)117 while ( ptr->next != NULL ) {118 if ( ptr->next->info == element ) {119 Node<DataType> *tempPtr = ptr->next;120 element = tempPtr->info;121 ptr->next = tempPtr->next;122 delete tempPtr;123 return true;124 }125 ptr = ptr->next;126 }127128 return false;129 }

37

isEmpty

130 template <class DataType>131 bool LinkedList<DataType>::isEmpty( ) const132 133 {134 return start == NULL;135 }

38

makeEmpty

136 template <class DataType>137 void LinkedList<DataType>::makeEmpty( ) 138 {139 while ( start != NULL ) {140 current = start;141 start = start->next;142 delete current;143 }144145 current = NULL;146 }

39

deepCopy147 template <class DataType>148 inline void LinkedList<DataType>::deepCopy( 149 const LinkedList<DataType> & original )150 {151 start = current = NULL;152 if ( original.start == NULL )153 return;154 Node<DataType> *copyptr = start = 155 new Node<DataType>;156 Node<DataType> *originalptr = original.start;157 copyptr->info = originalptr->info;

deepCopy continued…

40

deepCopy (cont.)158 if ( originalptr == original.current )159 current = copyptr;160 while ( originalptr->next != NULL ) {161 originalptr = originalptr->next;162 copyptr->next = new Node<DataType>;163 copyptr = copyptr->next;164 copyptr->info = originalptr->info;165 if ( originalptr == original.current )166 current = copyptr;167 }168 copyptr->next = NULL;169 }

Special code to set current pointer in copy correctly.

41

Sorted Linked List

• A sorted linked list is one in which the elements are placed in order (usually by key value)

start 4 5 7 93

42

Sorted Linked List (cont.)

• Insertion is no longer ( 1 ), but is ( n ) on average

• Find and retrieve functions are faster, on average, if the element is not in the list– Once you reach a point in the list where the

element you are looking for is greater, then you know it is not in the list

– Still ( n ) on average

43

Circular Linked List

current

44

Doubly-Linked Liststart

…

Given a pointer to a node in a doubly-linked list, we can remove the node in ( 1 ) time.

This isn’t possible in a singly-linked list, since we must have a pointer to the node in front of the one we want to remove.

45

Doubly-Linked Liststart

…

template <class DataType>struct DLNode {

DataType info;DLNode<DataType> *next;DLNode<DataType> *back;

};

Each node is made from a struct that looks something like this.

46

Doubly-Linked Liststart

…

47

Doubly-Linked Liststart

…

ptr

48

Doubly-Linked Liststart

…

ptr

ptr->back->next = ptr->next;ptr->next->back = ptr->back;delete ptr;

49

Doubly-Linked Liststart

…

ptr

ptr->back->next = ptr->next;ptr->next->back = ptr->back;delete ptr;

50

Doubly-Linked Liststart

…

ptr

ptr->back->next = ptr->next;ptr->next->back = ptr->back;delete ptr;

51

Doubly-Linked Liststart

…

ptr

ptr->back->next = ptr->next;ptr->next->back = ptr->back;delete ptr;

52

Doubly-Linked Liststart

…

ptr

ptr->back->next = ptr->next;ptr->next->back = ptr->back;delete ptr;

53

Doubly-Linked Liststart

…

ptr

ptr->back->next = ptr->next;ptr->next->back = ptr->back;delete ptr;

54

Doubly-Linked Liststart

…

ptr

ptr->back->next = ptr->next;ptr->next->back = ptr->back;delete ptr;