Transcript PowerPoint Slides for Starting Out with C++ Early Object

Chapter 17: Linked Lists
Starting Out with C++
Early Objects
Seventh Edition
by Tony Gaddis, Judy Walters,
and Godfrey Muganda
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17.1 Introduction to the Linked List ADT
• Linked list: a sequence of data structures (nodes) with
each node containing a pointer to its successor
• The last node in the list has its successor pointer set to
NULL
NULL
list
head
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-2
Linked List Terminology
• The node at the beginning is called the
head of the list
• The entire list is identified by the pointer
to the head node. This pointer is called
the list head.
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-3
Linked Lists
• Nodes can be added or removed from
the linked list during execution
• Addition or removal of nodes can take
place at beginning, end, or middle of the
list
list
head
Add or delete node
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
NULL
17-4
Linked Lists vs. Arrays and Vectors
• Linked lists can grow and shrink as
needed, unlike arrays, which have a fixed
size
• Unlike vectors, insertion or removal of a
node in the middle of the list is very efficient
NULL
list
head
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-5
Node Organization
A node contains:
– data: one or more data fields – may be
organized as structure, object, etc.
– a pointer that can point to another node
pointer
data
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-6
Empty List
• A list with no nodes is called the empty
list
• In this case the list head is set to NULL
list
head
NULL
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-7
C++ Implementation
Implementation of nodes requires a
structure containing a pointer to a structure
of the same type:
struct ListNode
{
int data;
ListNode *next;
};
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-8
struct ListNode
{ double value;
ListNode *next;
};
int main()
{ ListNode *head;
// Create first node with 12.5
head = new ListNode;
// Allocate new node
head->value = 12.5;
// Store the value
head->next = NULL;
// Signify end of list
// Create second node with 13.5
ListNode *secondPtr = new ListNode;
secondPtr->value = 13.5;
secondPtr->next = NULL; // Second node is end of list
head->next = secondPtr; // First node points to second
// Print the list.
cout << "First item is " << head->value << endl;
cout << "Second item is " << head->next->value << endl;
return 0;
}
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-9
C++ Implementation
Nodes can be equipped with constructors:
struct ListNode
{
int data;
ListNode *next;
ListNode(int d, ListNode* p=NULL)
{data = d; next = p;}
};
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-10
17.2 Linked List Operations
• Basic operations:
– add a node to the end of the list
– insert a node within the list
– traverse the linked list
– delete a node
– delete/destroy the list
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-11
Creating an Empty List
• Define a pointer for the head of the list:
ListNode *head = NULL;
• Head pointer initialized to NULL to indicate
an empty list
head
NULL
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-12
NULL Pointer
• Is used to indicate end-of-list
• Should always be tested for before using a
pointer:
ListNode *p;
while (p != NULL) ...
• Can also test the pointer itself:
while (!p) ... // same meaning
// as above
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
13
Creating a Node
ListNode *p;
int num = 23;
p = new ListNode(num);
p
23
NULL
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-14
Creating a New Node
• Allocate memory for the new node:
newNode
newNode = new ListNode;
• Initialize the contents of the node:
newNode
newNode->value = num;
23
• Set the pointer field to NULL:
newNode
newNode->next = NULL;
23
NULL
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
15
struct ListNode
{ double value;
ListNode *next;
ListNode(double value1, ListNode *next1 = NULL)
{ value = value1;
next = next1;
}
};
int main()
{ ListNode *numberList = NULL;
// List of numbers
ifstream numberFile("numberFile.dat");
if (!numberFile)
{ cout << "Error in opening the file of numbers."; exit(1);
double number;
cout << "The contents of the file are: " << endl;
while (numberFile >> number)
{ cout << number << " ";
numberList = new ListNode(number, numberList);
}
cout << endl << "The contents of the list are: " << endl;
ListNode *ptr = numberList;
while (ptr != NULL)
{ cout << ptr->value << " "; // Process node
ptr = ptr->next;
// Move to next node
}
return 0;
}
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
}
17-16
A
numberList ----------------10
----------------NULL
numberList
numberList
numberList
node address
----------------------value
-----------------------next
B
----------------20
----------------A
A
----------------10
----------------NULL
C
----------------30
----------------B
B
----------------20
----------------A
D
----------------40
----------------C
C
----------------30
----------------B
A
----------------10
----------------NULL
B
----------------20
----------------A
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
A
----------------10
----------------NULL
17-17
Appending an Item
• To add an item to the end of the list:
– If the list is empty, set head to a new node
containing the item
head = new ListNode(num);
– If the list is not empty, move a pointer p to
the last node, then add a new node
containing the item
p->next = new ListNode(num);
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-18
Appending an Item
p
5
13
23
NULL
list
head
List originally has 5, 13.
p locates the last node,
then a node with a new
item, 23, is added
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-19
Appending a Node
nodePtr
5
13
19
NULL
list
head
23
NULL
newNode
New node created, end of list located
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
20
Appending a Node
nodePtr
5
13
19
list
head
23
NULL
newNode
New node added to end of list
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
21
//NumberList.h
class NumberList
{
protected:
// Declare a class for the list node.
struct ListNode
{
double value;
ListNode *next;
ListNode(double value1, ListNode *next1 = NULL)
{ value = value1;
next = next1;
}
};
ListNode *head;
// List head pointer
public:
NumberList() { head = NULL; }
// Constructor
~NumberList();
// Destructor
void add(double number);
void remove(double number);
void displayList();
};
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-22
//NumberList.cpp
#include "NumberList.h"
using namespace std;
//*****************************************************
// add adds a new element to the end of the list.
*
//*****************************************************
void NumberList::add(double number)
{ if (head == NULL)
head = new ListNode(number);
else
{
// The list is not empty. Use nodePtr to traverse the list
ListNode *nodePtr = head;
while (nodePtr->next != NULL)
nodePtr = nodePtr->next;
// nodePtr->next is NULL so nodePtr points to the last node.
// Create a new node and put it after the last node.
nodePtr->next = new ListNode(number);
}
}
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-23
//NumberList.cpp
// displayList outputs all values currently stored in the list.
void NumberList::displayList()
{ ListNode *nodePtr = head;
// Start at head of list
while (nodePtr)
{ // Print the value in the current node
cout << nodePtr->value << "
";
nodePtr = nodePtr->next; // Move on to the next node
}
}
// Destructor deallocates the memory used by the list.
NumberList::~NumberList()
{ ListNode *nodePtr = head; // Start at head of list
while (nodePtr != NULL)
{
// garbage keeps track of node to be deleted
ListNode *garbage = nodePtr;
nodePtr = nodePtr->next; // Move on to the next node, if any
delete garbage; // Delete the "garbage" node
}
}
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-24
//main.cpp
// This program demonstrates the add and
// display linked list operations.
#include "Numberlist.h"
using namespace std;
int main()
{
NumberList list;
list.add(2.5);
list.add(7.9);
list.add(12.6);
list.displayList();
cout << endl;
return 0;
}
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-25
Inserting a Node
• Used to insert an item into a sorted list,
keeping the list sorted.
• Two possibilities:
– Insertion is at the head of the list (because
item at head is already greater than item
being inserted, or because list is empty
– Insertion is after an existing node in a nonempty list
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-26
Inserting a Node in Body of a List
• Requires two pointers to traverse the list:
– pointer to locate the node with data value
greater than that of node to be inserted
– pointer to 'trail behind' one node, to point to
node before point of insertion
• New node is inserted between the nodes
pointed at by these pointers
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-27
Inserting a Node at Head of a List
• Test to see if
– head pointer is null, or
– node value pointed at by head is greater
than value to be inserted
• Must test in this order: unpredictable
results if second test is attempted on an
empty list
• Create new node, set its next pointer to
head, then point head to it
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-28
Inserting a Node into a
Linked List
previousNode
5
13
19
nodePtr
NULL
list
head
17
NULL
newNode
Item to insert
Correct position located
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-29
Inserting a Node into a
Linked List
previousNode
5
list
head
13
19
nodePtr
NULL
17
New node created and inserted in order in the linked list
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-30
Traversing a Linked List
• List traversals visit each node in a linked list
to display contents, validate data, etc.
• Basic process of traversal:
set a pointer to the head pointer
while pointer is not NULL
process data
set pointer to the successor of the current node
end while
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-31
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
32
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
33
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
34
Traversing a Linked List
• Visit each node in a linked list: display
contents, validate data, etc.
• Basic process:
– set a pointer to the contents of the head pointer
– while pointer is not NULL
• process data
• go to the next node by setting the pointer to the
pointer field of the current node in the list
– end while
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
35
Traversing a Linked List
nodePtr
5
13
19
NULL
list
head
nodePtr points to the node containing 5, then the
node containing 13, then the node containing 19,
then points to NULL, and the list traversal stops
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-36
Removing an Element
• Used to remove a node from a linked list
• If list uses dynamic memory, then delete
node from memory
• Requires two pointers: one to locate the
node to be deleted, one to point to the
node before the node to be deleted
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-37
Deleting a Node
Contents of node to
be deleted: 13
previousNode
5
nodePtr
13
19
NULL
list
head
Locating the node containing 13
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-38
Deleting a Node
previousNode
5
nodePtr
13
19
NULL
list
head
Adjusting pointer around the node to be deleted
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-39
Deleting a Node
previousNode
5
nodePtr
19
NULL
list
head
Linked list after deleting the node containing 13
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-40
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
41
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
42
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
43
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
44
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
45
Destroying a Linked List
• Must remove all nodes used in the list
• To do this, use list traversal to visit each
node
• For each node,
– Unlink the node from the list
– Free the node’s memory
• Finally, set the list head to NULL
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-46
CIS 15 Linked Lists
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
47
17.3 A Linked List Template
• A linked list template can be written by
replacing the type of the data in the node
with a type parameter, say T.
• If defining the linked list as a class
template, then all member functions must
be function templates
• Implementation assumes use with data
types that support comparison: == and <=
• project LinkedListTemplate
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-48
17.4 Recursive Linked List Operations
• A non-empty linked list consists of a
head node followed by the rest of the
nodes
• The rest of the nodes form a linked list
that is called the tail of the original list
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-49
Recursive Linked List Operations
Many linked list operations can be
broken down into the smaller problems
of processing the head of the list and
then recursively operating on the tail of
the list
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-50
Recursive Linked List Operations
To find the length (number of elements) of
a list
– If the list is empty, the length is 0 (base
case)
– If the list is not empty, find the length of the
tail and then add 1 to obtain length of
original list
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-51
Recursive Linked List Operations
To find the length of a list:
int length(ListNode *myList)
{
if (myList == NULL) return 0;
else
return 1 + length(myList->next);
}
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-52
Other Recursive Linked List Operations
General design considerations:
• Base case is often when the list is empty
• Recursive case often involves the use of the tail
of the list (i.e., the list without the head). Since
the tail has one fewer entry than the list that was
passed in to this call, the recursion eventually
stops.
• project LinkedListRecursive
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-53
17.5 Variations of the Linked List
Other linked list organizations:
– doubly-linked list: each node contains two
pointers: one to the next node in the list, one to
the previous node in the list
5
list
head
13
19
NULL
NULL
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-54
Variations of the Linked List
Other linked list organizations:
– circular linked list: the last node in the list
points back to the first node in the list, not to
NULL
5
13
19
list
head
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-55
17.6 The STL list Container
• Template for a doubly linked list
• Member functions for
– locating beginning, end of list: front,
back, end
– adding elements to the list: insert,
merge, push_back, push_front
– removing elements from the list: erase,
pop_back, pop_front, unique
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-56
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-57
#include <iostream>
#include <list>
// Include the list header
using namespace std;
int main()
{
list<int> myList;
list<int>::iterator iter;
// Add values to the list.
for (int x = 0; x < 100; x += 10) myList.push_back(x);
// Display the values.
for (iter = myList.begin(); iter != myList.end(); iter++)
cout << *iter << " "; cout << endl;
myList.reverse(); //reverse the order of the elements.
// Display the values again.
for (iter = myList.begin(); iter != myList.end(); iter++)
cout << *iter << " "; cout << endl;
return 0;
}
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley
17-58
Chapter 17: Linked Lists
Starting Out with C++
Early Objects
Seventh Edition
by Tony Gaddis, Judy Walters,
and Godfrey Muganda
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley