C++ Programming: From Problem Analysis to Program Design, Second Edition

C++ Programming: From Problem Analysisto Program Design, Second Edition

Chapter 17: Linked Lists

C++ Programming: From Problem Analysis to Program Design, Second Edition 2

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


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


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


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 structs--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’


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


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


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


Pointer Dereferencing and Member Selection

. info . link

‘A’ 6000 ptr

ptr

ptr

. info . link

‘A’ 6000

*ptr

ptr

. info . link

(*ptr).info

ptr->info

‘A’ 6000


ptr is a pointer to a node

. info . link

‘A’ 6000 ptr

ptr


*ptr is the entire node pointed to by ptr

ptr

. info . link

‘A’ 6000

*ptr


ptr->info is a node member

ptr

. info . link

ptr->info

(*ptr).info // equivalent

‘A’ 6000


ptr->link is a node member

ptr

. info . link

ptr->link

(*ptr).link // equivalent

‘A’ 6000


Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

ptr

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head



ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 3000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 3000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 3000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 5000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 5000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 5000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr NULL

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head




ptr = head ;


cout << ptr->info ;


ptr = ptr->link ;

}

ptr NULL

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head


C++ Programming: From Problem Analysis to Program Design, Second Edition

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


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;


‘B’item




NodeType* location;




head = location;


‘B’item

location




NodeType* location;




head = location;


‘B’item

location




NodeType* location;




head = location;


‘B’item

location ‘B’




NodeType* location;




head = location;


‘B’item

location ‘B’




NodeType* location;




head = location;


‘B’item

location ‘B’

C++ Programming: From Problem Analysis to Program Design, Second Edition

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


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



NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

head

item

‘B’ ‘X’ ‘C’ ‘L’

tempPtr

‘B’



NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

head

item

‘B’ ‘X’ ‘C’ ‘L’

tempPtr

‘B’



NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

head

item

‘B’ ‘X’ ‘C’ ‘L’

tempPtr

‘B’



NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

head

item

‘X’ ‘C’ ‘L’

tempPtr

‘B’


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


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


// 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 ( ) ; // DestructorSortedList2 ( const SortedList2& otherList ) ; // Copy-constructor

private :

NodeType* head;} ;

41


class SortedList2

Print

~SortedList2

Insert

InsertTop

SortedList2

IsEmpty

Delete

‘C’ ‘L’ ‘X’

Private data:

head

DeleteTop


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?


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


Implementing SortedList2Member 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{

.

.

.

}


Inserting ‘S’ into a Sorted List

‘C’ ‘L’ ‘X’

Private data:

head

prevPtr currPtr


Finding Proper Position for ‘S’

‘C’ ‘L’ ‘X’

Private data:

head

prevPtr currPtr

NULL


‘C’ ‘L’ ‘X’

Private data:

head

prevPtr currPtr



‘C’ ‘L’ ‘X’

Private data:

head

prevPtr currPtr



‘C’ ‘L’ ‘X’

Private data:

head

prevPtr currPtr

Inserting ‘S’ into Proper Position

‘S’


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


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 hereif ( prevPtr == NULL )

head = location ;else

prevPtr->link = location ;}

52


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


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


class SortedList2

Print

~SortedList2

Insert

InsertTop

SortedList2

IsEmpty

Delete

‘C’ ‘L’ ‘X’

Private data:

head

DeleteTop


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


Doubly Linked Lists

• Doubly linked list: every node has next and back pointers

• Can be traversed in either direction


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


Delete a Node

• Consider the list shown in the figure below


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


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


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


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


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


Part 2: Customer Component

• Primary characteristics of a customer:

− First name

− Last name

− Account number

− List of rented videos


Basic Operations

• Basic operations on personType:

− Print the name

− Set the name

− Show the first name

− Show the last name


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 #


Main Program

• The data in the input file is in the form:video titlemovie star1movie star2movie producermovie directormovie production co.number of copies...


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


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


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


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


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


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

C++ Programming: From Problem Analysis to Program Design, Second Edition

Documents