1

Linked Lists

Lecture 3

Asad Anwar Butt

 2

Introduction to the Linked List ADT

• A linked list is a series of connected nodes, where each
node is a data structure.
• Linear relationship between elements:
(1) Each element except the first one has a
predecessor.
(2) Each element except the last one has a
successor.
• Length: the number of items in the list.
 3

Singly Linked List

• Simplest form of linked list
• Each node in a linked list contains one or more
members that represent data.
• In addition to the data, each node contains a pointer,
which can point to another node.
 4

The composition of a Linked List

• A linked list is called "linked" because each node in the

series has a pointer that points to the next node in the
list.
 5

Linked list data structure

• One of the attributes of a linked list is that there is not a physical
relationship between the nodes; that is, they are not stored
contiguously in memory (unlike array elements).
• To determine the beginning of the list, and each additional
element in the list, we need to use pointers.
 6

Linked list data structure

 The pointer to the first node in the list is referred to as the head
pointer, because it points to the head node in the list

 In addition to the head pointer, there are usually other pointers

associated with the list. These can include a pointer to the last
element in the list (tail pointer) and a pointer that traverses the
list to find data (navigator or traversal pointer)
 7

Singly Linked List

Linked List object
head size tail
3

Node objects

Data Fields
Link Fields
 8

Linked list data structure

 Normally we create a structure that contains the head pointer of
a list and also information about the list itself (e.g., number of
elements currently in the list, tail pointer, etc).
 This extra data is referred to as metadata.
 9

Declarations Singly linked list

• First you must declare a data structure that will be
used for the nodes. For example, the following
struct could be used to create a list where each
node holds a float:

struct ListNode
{
float value;
struct ListNode *next;
};
 10

Declarations
• The next step is to declare a pointer to serve as the list
head, as shown below.

ListNode *head;

• Once you have declared a node data

structure and have created a NULL head
pointer, you have an empty linked list.
• The next step is to implement operations
with the list.
 11

Linked list operations

 In a linked list, there are a standard set of functions that operate
on the list:
 Creating the list
Initialize pointers to NULL;
 Inserting nodes
Insert at beginning
Insert at middle
Insert at last
 Deleting nodes
Delete from beginning, middle, last
 Traversing the list
 Searching a specified item in the list
 Destroying the list
 12

Linked List Operations

• We will use the following class declaration (on the

next slide), which is stored in FloatList.h.
class FloatList 13

{
private: // Declare a structure for the list
struct ListNode
{
float value;
struct ListNode *next;
};
ListNode *head; // List head pointer
public:
FloatList(void) // Constructor
{
head = NULL;
}

~FloatList(void) { }; // Destructor
void appendNode(float);
void insertNode(float);
void deleteNode(float);
void displayList(void);
};
 14

Appending a Node to the List

• To append a node to a linked list means to add the node to
the end of the list.
• The pseudocode is shown below. The C++ code follows.

Create a new node.

Store data in the new node.
If there are no nodes in the list
Make the new node the first node.
Else
Traverse the List to Find the last node.
Add the new node to the end of the list.
End If.
 15
void FloatList::appendNode(float num)
{
ListNode *newNode, *nodePtr;

// Allocate a new node & store num

newNode = new ListNode;
newNode->value = num;
newNode->next = NULL;
// If there are no nodes in the list
// make newNode the first node
if (!head) // head == NULL
head = newNode;
else// Otherwise, insert newNode at end
{
// Initialize nodePtr to head of list
nodePtr = head;
// Find the last node in the list
while (nodePtr->next)
nodePtr = nodePtr->next;
// Insert newNode as the last node
nodePtr->next = newNode;
}
}
 16

Program 1
// This program demonstrates a simple append
// operation on a linked list.
#include <iostream.h>
#include "FloatList.h”

void main(void)
{
FloatList list;

list.appendNode(2.5);
list.appendNode(7.9);
list.appendNode(12.6);
}
(This program displays no output.)
 17

Stepping Through the Program

• The head pointer is declared as a global

variable. head is automatically initialized to 0
(NULL), which indicates that the list is empty.
• The first call to appendNode passes 2.5 as
the argument. In the following statements, a
new node is allocated in memory, 2.5 is copied
into its value member, and NULL is assigned
to the node's next pointer.
 18

newNode = new ListNode;

newNode->value = num;
newNode->next = nULL;
 19

The next statement to execute is the following if statement.

if (!head)
head = newNode;

There are no more statements to execute, so control returns to

function main.
 20

In the second call to appendNode, 7.9 is passed as the argument.

Once again, the first three statements in the function create a new
node, store the argument in the node's value member, and assign
its next pointer to NULL.
 21

Since head no longer points to NULL, the else part of the if statement executes:
else // Otherwise, insert newNode at end
{
// Initialize nodePtr to head of list
nodePtr = head;
// Find the last node in the list
while (nodePtr->next)
nodePtr = nodePtr->next;
// Insert newNode as the last node
nodePtr->next = newNode;
}
 22

nodePtr is already at the end of the list, so the while loop

immediately terminates. The last statement, nodePtr->next =
newNode; causes nodePtr->next to point to the new node.
This inserts newNode at the end of the list.
 23

The third time appendNode is called, 12.6 is passed as the

argument. Once again, the first three statements create a node with
the argument stored in the value member.
 24

next, the else part of the if statement executes. As before,

nodePtr is made to point to the same node as head.
 25

Since nodePtr->next is not NULL, the while loop will

execute. After its first iteration, nodePtr will point to the second
node in the list.
 26

The while loop's conditional test will fail after the first iteration
because nodePtr->next now points to NULL. The last
statement, nodePtr->next = newNode; causes
nodePtr->next to point to the new node. This inserts newNode
at the end of the list

The figure above depicts the final state of the linked list.
 27

Traversing the List

• Algorithms that traverse a list start at the
first node and examine each node in
succession until the last node has been
processed
• Traversal logic is used by several different
types of algorithms, such as
– changing a value in each node,
– printing the list,
– Performing an operation on a field in the list,
– or calculating the average of a field and etc…
• Any application that requires that the
entire list be processed uses the traversal
 28

Traversing the List

• To traverse the list we need a walking
(navigator/traversal) pointer

• This pointer is used to move from node to

node as each element is processed
• Example is our displayList function….
 29

Traversing the List

• The displayList member function traverses the list,
displaying the value member of each node. The following
pseudocode represents the algorithm. The C++ code for
the member function follows on the next slide.

Assign List head to node pointer.

While node pointer is not NULL
Display the value member of the node pointed to by node pointer.
Assign node pointer to its own next member.
End While.
 30

void FloatList::displayList(void)
{
ListNode *nodePtr;

nodePtr = head;
while (nodePtr)
{
cout << nodePtr->value << endl;
nodePtr = nodePtr->next;
}
}
 31

Program 2
// This program calls the displayList member function.
// The funcion traverses the linked list displaying
// the value stored in each node.
#include <iostream.h>
#include "FloatList.h"

void main(void)
{
FloatList List;

list.appendNode(2.5);
list.appendNode(7.9);
list.appendNode(12.6);
list.displayList();
}
 32

Program 17-2 Output

2.5
7.9
12.6
 33

Inserting a Node
• Using the listNode structure again, the pseudocode on
the next slide shows an algorithm for finding a new node’s
proper position in the list and inserting there.
• The algorithm assumes the nodes in the list are already in
order.
 34

Inserting a Node

Create a new node.

Store data in the new node.
If there are no nodes in the list
Make the new node the first node.
Else
Find the first node whose value is greater than or equal
the new value, or the end of the list (whichever is first).
Insert the new node before the found node, or at the end of
the list if no node was found.
End If.
 35
The code for the traversal algorithm is shown below. (As before, num
holds the value being inserted into the list.)

// Initialize nodePtr to head of list

nodePtr = head;

// Skip all nodes whose value member is less

// than num.
while (nodePtr != NULL && nodePtr->value < num)
{
previousNode = nodePtr;
nodePtr = nodePtr->next;
}

The entire insertNode function begins on the next slide.

void FloatList::insertNode(float num) 36
{
ListNode *newNode, *nodePtr, *previousNode = NULL;

// Allocate a new node & store Num

newNode = new ListNode;
newNode->value = num;

// If there are no nodes in the list

// make newNode the first node
if (!head) // if(head == NULL)
{
head = newNode;
newNode->next = NULL;
}
else // Otherwise, insert newNode.
{
// Initialize nodePtr to head of list
nodePtr = head;

// Skip all nodes whose value member is less than num.

while (nodePtr != NULL && nodePtr->value < num)
{
previousNode = nodePtr;
nodePtr = nodePtr->next; Continued on next slide…
}
 37
Continued from previous slide.

// If the new node is to be the 1st in the list,

// insert it before all other nodes.
if (previousNode == NULL)
{
head = newNode;
newNode->next = nodePtr;
}
else
{
previousNode->next = newNode;
newNode->next = nodePtr;
}
}
}
 38

Program 3
// This program calls the displayList member function.
// The function traverses the linked list displaying
// the value stored in each node.
#include <iostream.h>
#include "FloatList.h”

void main(void)
{
FloatList list;

// Build the list

list.appendNode(2.5);
list.appendNode(7.9);
list.appendNode(12.6);

// Insert a node in the middle

// of the list.
list.insertNode(10.5);

// Dispay the list

list.displayList();
}
 39

Program 17-3 Output

2.5
7.9
10.5
12.6
 40
In insertNode, a new node is created and the function argument is
copied to its value member. Since the list already has nodes stored
in it, the else part of the if statement will execute. It begins by
assigning nodePtr to head.
 41

Since nodePtr is not NULL and nodePtr->value is less than

num, the while loop will iterate. During the iteration,
previousNode will be made to point to the node that nodePtr is
pointing to. nodePtr will then be advanced to point to the next
node.
 42

Once again, the loop performs its test. Since nodePtr is not NULL
and nodePtr->value is less than num, the loop will iterate a
second time. During the second iteration, both previousNode and
nodePtr are advanced by one node in the list.
 43

This time, the loop's test will fail because nodePtr is not less than
num. The statements after the loop will execute, which cause
previousNode->next to point to newNode, and
newNode->next to point to nodePtr.

If you follow the links, from the head pointer to the NULL, you will
see that the nodes are stored in the order of their value members.
 44

Deleting a Node
• Deleting a node from a linked list requires two steps:
• Remove the node from the list without breaking the links created by
the next pointers
• Deleting the node from memory
• The deleteNode function begins on the next slide.
 45
void FloatList::deleteNode(float num)
{
ListNode *nodePtr, *previousNode;

// If the list is empty, do nothing.

if (!head)
return;

// Determine if the first node is the one.

if (head->value == num)
{
nodePtr = head->next;
delete head;
head = nodePtr;
} Continued on next slide…

Next slide: Home assignment

 46
Continued from previous slide.
else
{
// Initialize nodePtr to head of list
nodePtr = head;

// Skip all nodes whose value member is not equal to

num.
while (nodePtr != NULL && nodePtr->value != num)
{
previousNode = nodePtr;
nodePtr = nodePtr->next;
}

// Link the previous node to the node after nodePtr,

then delete nodePtr.
previousNode->next = nodePtr->next;
delete nodePtr;
}
}
 47

Program 4
// This program demonstrates the deleteNode member function
#include <iostream.h>
#include "FloatList.h“

void main(void)
{
FloatList list;

// Build the list

list.appendNode(2.5);
list.appendNode(7.9);
list.appendNode(12.6);
cout << "Here are the initial values:\n";
list.displayList();
cout << endl;

cout << "Now deleting the node in the middle.\n";

cout << "Here are the nodes left.\n";
list.deleteNode(7.9);
list.displayList(); Continued on next slide…
cout << endl;
 48
Continued from previous slide.

cout << "Now deleting the last node.\n";

cout << "Here are the nodes left.\n";
list.deleteNode(12.6);
list.displayList();
cout << endl;

cout << "Now deleting the only remaining node.\n";

cout << "Here are the nodes left.\n";
list.deleteNode(2.5);
list.displayList();
}
 49

Program Output

Here are the initial values:

2.5
7.9
12.6

Now deleting the node in the middle.

Here are the nodes left.
2.5
12.6

Now deleting the last node.

Here are the nodes left.
2.5

Now deleting the only remaining node.

Here are the nodes left.
 50

Look at the else part of the second if statement. This is where the
function will perform its action since the list is not empty, and the
first node does not contain the value 7.9. Just like insertNode,
this function uses nodePtr and previousNode to traverse the
list. The while loop terminates when the value 7.9 is located. At this
point, the list and the other pointers will be in the state depicted in the
figure below.
 51
next, the following statement executes.
previousNode->next = nodePtr->next;
The statement above causes the links in the list to bypass the node
that nodePtr points to. Although the node still exists in memory, this
removes it from the list.

The last statement uses the delete operator to complete the total
deletion of the node.
 52

Destroying the List

• The class's destructor should release all the memory used
by the list.
• It does so by stepping through the list, deleting each node
one-by-one. The code is shown on the next slide.
 53

FloatList::~FloatList(void)
{
ListNode *nodePtr, *nextNode;

nodePtr = head;
while (nodePtr != NULL)
{
nextNode = nodePtr->next;
delete nodePtr;
nodePtr = nextNode;
}
}

Notice the use of nextNode instead of previousNode. The

nextNode pointer is used to hold the position of the next node in
the list, so it will be available after the node pointed to by nodePtr
is deleted.
 54

Questions