Linked Lists
Muhammad Hammad Waseem
m.hammad.wasim@gmail.com
2
Introduction to the Linked List
• A linked list is a series of connected nodes, where each node is a data
structure.
• A linked list can grow or shrink in size as the program runs
3
Advantages of Linked Lists over Arrays and
Vectors
• A linked list can easily grow or shrink in size.
• Insertion and deletion of nodes is quicker with linked lists than with
vectors.
The Composition of a 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
Declarations
• 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:
6
struct ListNode
{
float value;
struct ListNode *next;
};
Declarations
• The next step is to declare a pointer to serve as the list head, as
shown below.
•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.
7
ListNode *head;
Linked List Operations
• Different operations can be performed on list such as:
• Append
• Insert
• Delete
• Display / Traversing
• We will use the following class declaration (on the next slide), which is
stored in FloatList.h.
8
9
class FloatList
{
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);
};
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.
10
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.
11
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->next!=null
nodePtr = nodePtr->next;
// Insert newNode as the last node
nodePtr->next = newNode;
}
}
Code Segment appendNode
12
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.)
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.
13
newNode = new ListNode;
newNode->value = num;
newNode->next = NULL;
14
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.
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.
SECOND FUNCTION CALL
15
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;
}
• 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.
16
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.
THIRD FUNCTION CALL
next, the else part of the if statement executes. As before, nodePtr is made to
point to the same node as head.
17
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.
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.
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.
18
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.
Code Segment displayList
19
void FloatList::displayList(void)
{
ListNode *nodePtr;
nodePtr = head;
while (nodePtr)
{
cout << nodePtr->value << endl;
nodePtr = nodePtr->next;
}
}
Program: 2
20
// 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();
}
2.5
7.9
12.6
Output:
21
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.
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.
22
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.
23
void FloatList::insertNode(float num)
{
ListNode *newNode, *nodePtr, *previousNode;
// 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)
{
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…
24
// If the new node is to be the 1st in the list,
// insert it before all other nodes.
if (previousNode == NULL)
{
head = newNode;
newNode-> = nodePtr;
}
else
{
previousNode->next = newNode;
newNode->next = nodePtr;
}
}
}
Continued from previous slide.
Program: 3
25
// 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();
}
2.5
7.9
10.5
12.6
Output:
26
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.
Stepping Through the Program
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.
27
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.
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.
28
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.
29
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…
30
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;
}
}
Continued from previous slide.
Program: 4
31
// 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();
cout << endl;
Continued on next slide…
32
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();
}
Continued from previous slide.
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.
33
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.
Stepping Through the Program
34
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.
35
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.
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.
Assignment: Variations of the Linked List
36
The Doubly-Linked List
The Circular Linked List
• Implementation of these two variations in
C++ using OOP
• Submit softcopy of your codes on
m.hammad.wasim@gmail.com before
Wednesday, Jan, 07. 3:00 PM

More Related Content

PPT
Singly link list
PPTX
Queue - Data Structure - Notes
PPTX
Different types of Linked list.
PPTX
Linked List - Insertion & Deletion
PPT
Algorithm analysis
PPTX
Singly & Circular Linked list
PPTX
Deque and its applications
PPTX
Linked list in Data Structure and Algorithm
Singly link list
Queue - Data Structure - Notes
Different types of Linked list.
Linked List - Insertion & Deletion
Algorithm analysis
Singly & Circular Linked list
Deque and its applications
Linked list in Data Structure and Algorithm

What's hot (20)

PPTX
PPT
Binary search tree(bst)
PDF
sparse matrix in data structure
PPTX
Breadth First Search & Depth First Search
PDF
Expression trees
PPT
Data Structures- Part7 linked lists
PPTX
single linked list
PPTX
Linked list
PPTX
Binary Search Tree in Data Structure
PPTX
Hashing
PPTX
Doubly Linked List
PPTX
linked list in data structure
PPTX
Priority Queue in Data Structure
PPTX
PPTX
Data structure - Graph
PPT
Skip list vinay khimsuriya_200430723005
PPTX
Stack & Queue using Linked List in Data Structure
PPT
Linked list
PPTX
Graph representation
PPT
Binary tree
Binary search tree(bst)
sparse matrix in data structure
Breadth First Search & Depth First Search
Expression trees
Data Structures- Part7 linked lists
single linked list
Linked list
Binary Search Tree in Data Structure
Hashing
Doubly Linked List
linked list in data structure
Priority Queue in Data Structure
Data structure - Graph
Skip list vinay khimsuriya_200430723005
Stack & Queue using Linked List in Data Structure
Linked list
Graph representation
Binary tree
Ad

Viewers also liked (7)

DOC
Student record
PPT
មេរៀនៈ Data Structure and Algorithm in C/C++
PDF
Data structures / C++ Program examples
PPT
Lecture 1 data structures and algorithms
PPTX
Data structure and its types
PPTX
STACKS IN DATASTRUCTURE
PPT
DATA STRUCTURES
Student record
មេរៀនៈ Data Structure and Algorithm in C/C++
Data structures / C++ Program examples
Lecture 1 data structures and algorithms
Data structure and its types
STACKS IN DATASTRUCTURE
DATA STRUCTURES
Ad

Similar to Data Structures - Lecture 7 [Linked List] (20)

PPTX
Linked lists in Data Structure
PPT
Mi 103 linked list
PPT
Ch17
PPT
Algo>ADT list & linked list
PPTX
C Exam Help
PDF
Lec-4_Linked-List (1).pdf
PPTX
Singly Linked List_Operations-Traversal.pptx
PPTX
C Homework Help
PPT
Lec-6 List ADT & Linked Lists FOR BSCS STUDENTS
PPTX
Linked lists a
PPT
Savitch ch 13
PPTX
linkedlist-130914084342-phpapp02.pptx
PDF
Cpp lernaufgabe linked_list
PPTX
linked list.pptxdj bdjbhjddnbfjdndvdhbfvgh
PPTX
DSModule2.pptx
PPT
Savitch Ch 13
PPTX
Dounly linked list
PPTX
DSA chapter 4.pptxhdjaaaaaadjhsssssssssssssssssssssssssss
PPTX
Linked list
PPT
Link list part 1
Linked lists in Data Structure
Mi 103 linked list
Ch17
Algo>ADT list & linked list
C Exam Help
Lec-4_Linked-List (1).pdf
Singly Linked List_Operations-Traversal.pptx
C Homework Help
Lec-6 List ADT & Linked Lists FOR BSCS STUDENTS
Linked lists a
Savitch ch 13
linkedlist-130914084342-phpapp02.pptx
Cpp lernaufgabe linked_list
linked list.pptxdj bdjbhjddnbfjdndvdhbfvgh
DSModule2.pptx
Savitch Ch 13
Dounly linked list
DSA chapter 4.pptxhdjaaaaaadjhsssssssssssssssssssssssssss
Linked list
Link list part 1

More from Muhammad Hammad Waseem (20)

PDF
[ITP - Lecture 17] Strings in C/C++
PDF
[ITP - Lecture 16] Structures in C/C++
PDF
[ITP - Lecture 15] Arrays & its Types
PDF
[ITP - Lecture 14] Recursion
PDF
[ITP - Lecture 13] Introduction to Pointers
PDF
[ITP - Lecture 12] Functions in C/C++
PDF
[ITP - Lecture 11] Loops in C/C++
PDF
[ITP - Lecture 10] Switch Statement, Break and Continue Statement in C/C++
PDF
[ITP - Lecture 09] Conditional Operator in C/C++
PDF
[ITP - Lecture 08] Decision Control Structures (If Statement)
PDF
[ITP - Lecture 07] Comments in C/C++
PDF
[ITP - Lecture 06] Operators, Arithmetic Expression and Order of Precedence
PDF
[ITP - Lecture 05] Datatypes
PDF
[ITP - Lecture 04] Variables and Constants in C/C++
PDF
[ITP - Lecture 03] Introduction to C/C++
PDF
[ITP - Lecture 02] Steps to Create Program & Approaches of Programming
PDF
[ITP - Lecture 01] Introduction to Programming & Different Programming Languages
PPTX
[OOP - Lec 20,21] Inheritance
PPTX
[OOP - Lec 19] Static Member Functions
PPTX
[OOP - Lec 18] Static Data Member
[ITP - Lecture 17] Strings in C/C++
[ITP - Lecture 16] Structures in C/C++
[ITP - Lecture 15] Arrays & its Types
[ITP - Lecture 14] Recursion
[ITP - Lecture 13] Introduction to Pointers
[ITP - Lecture 12] Functions in C/C++
[ITP - Lecture 11] Loops in C/C++
[ITP - Lecture 10] Switch Statement, Break and Continue Statement in C/C++
[ITP - Lecture 09] Conditional Operator in C/C++
[ITP - Lecture 08] Decision Control Structures (If Statement)
[ITP - Lecture 07] Comments in C/C++
[ITP - Lecture 06] Operators, Arithmetic Expression and Order of Precedence
[ITP - Lecture 05] Datatypes
[ITP - Lecture 04] Variables and Constants in C/C++
[ITP - Lecture 03] Introduction to C/C++
[ITP - Lecture 02] Steps to Create Program & Approaches of Programming
[ITP - Lecture 01] Introduction to Programming & Different Programming Languages
[OOP - Lec 20,21] Inheritance
[OOP - Lec 19] Static Member Functions
[OOP - Lec 18] Static Data Member

Recently uploaded (20)

PDF
gsas-cvs-and-cover-letters jhvgfcffttfghgvhg.pdf
PDF
V02-Session-4-Leadership-Through-Assessment-MLB.pdf
PDF
FYJC - Chemistry textbook - standard 11.
PDF
English 2nd semesteNotesh biology biopsy results from the other day and I jus...
PDF
New_Round_Up_6_SB.pdf download for free, easy to learn
PPTX
Single Visit Endodontics.pptx treatment in one visit
PPTX
Entrepreneurship Management and Finance - Module 1 - PPT
PDF
Teacher's Day Quiz 2025
PPTX
ENGlishGrade8_Quarter2_WEEK1_LESSON1.pptx
PDF
[Medicalstudyzone.com] 1. AIIMS NOV EMBER 2015 SOLVED PAPER.pdf
PPTX
Unit1_Kumod_deeplearning.pptx DEEP LEARNING
PDF
IS1343_2012...........................pdf
PPT
hsl powerpoint resource goyloveh feb 07.ppt
PDF
NGÂN HÀNG CÂU HỎI TÁCH CHỌN LỌC THEO CHUYÊN ĐỀ TỪ ĐỀ THI THỬ TN THPT 2025 TIẾ...
PDF
3-Elementary-Education-Prototype-Syllabi-Compendium.pdf
PPTX
Approach to a child with acute kidney injury
PPTX
Environmental Sciences and Sustainability Chapter 2
PDF
Physical pharmaceutics two in b pharmacy
PPTX
macro complete discussion with given activities
PDF
HSE and their team are going through the hazards of the issues with learning ...
gsas-cvs-and-cover-letters jhvgfcffttfghgvhg.pdf
V02-Session-4-Leadership-Through-Assessment-MLB.pdf
FYJC - Chemistry textbook - standard 11.
English 2nd semesteNotesh biology biopsy results from the other day and I jus...
New_Round_Up_6_SB.pdf download for free, easy to learn
Single Visit Endodontics.pptx treatment in one visit
Entrepreneurship Management and Finance - Module 1 - PPT
Teacher's Day Quiz 2025
ENGlishGrade8_Quarter2_WEEK1_LESSON1.pptx
[Medicalstudyzone.com] 1. AIIMS NOV EMBER 2015 SOLVED PAPER.pdf
Unit1_Kumod_deeplearning.pptx DEEP LEARNING
IS1343_2012...........................pdf
hsl powerpoint resource goyloveh feb 07.ppt
NGÂN HÀNG CÂU HỎI TÁCH CHỌN LỌC THEO CHUYÊN ĐỀ TỪ ĐỀ THI THỬ TN THPT 2025 TIẾ...
3-Elementary-Education-Prototype-Syllabi-Compendium.pdf
Approach to a child with acute kidney injury
Environmental Sciences and Sustainability Chapter 2
Physical pharmaceutics two in b pharmacy
macro complete discussion with given activities
HSE and their team are going through the hazards of the issues with learning ...

Data Structures - Lecture 7 [Linked List]

  • 2. 2 Introduction to the Linked List • A linked list is a series of connected nodes, where each node is a data structure. • A linked list can grow or shrink in size as the program runs
  • 3. 3 Advantages of Linked Lists over Arrays and Vectors • A linked list can easily grow or shrink in size. • Insertion and deletion of nodes is quicker with linked lists than with vectors.
  • 4. The Composition of a 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
  • 5. 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
  • 6. Declarations • 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: 6 struct ListNode { float value; struct ListNode *next; };
  • 7. Declarations • The next step is to declare a pointer to serve as the list head, as shown below. •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. 7 ListNode *head;
  • 8. Linked List Operations • Different operations can be performed on list such as: • Append • Insert • Delete • Display / Traversing • We will use the following class declaration (on the next slide), which is stored in FloatList.h. 8
  • 9. 9 class FloatList { 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); };
  • 10. 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. 10 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.
  • 11. 11 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->next!=null nodePtr = nodePtr->next; // Insert newNode as the last node nodePtr->next = newNode; } } Code Segment appendNode
  • 12. 12 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.)
  • 13. 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. 13 newNode = new ListNode; newNode->value = num; newNode->next = NULL;
  • 14. 14 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. 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. SECOND FUNCTION CALL
  • 15. 15 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; } • 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.
  • 16. 16 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. THIRD FUNCTION CALL next, the else part of the if statement executes. As before, nodePtr is made to point to the same node as head.
  • 17. 17 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. 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.
  • 18. 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. 18 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.
  • 19. Code Segment displayList 19 void FloatList::displayList(void) { ListNode *nodePtr; nodePtr = head; while (nodePtr) { cout << nodePtr->value << endl; nodePtr = nodePtr->next; } }
  • 20. Program: 2 20 // 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(); } 2.5 7.9 12.6 Output:
  • 21. 21 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. 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.
  • 22. 22 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.
  • 23. 23 void FloatList::insertNode(float num) { ListNode *newNode, *nodePtr, *previousNode; // 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) { 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…
  • 24. 24 // If the new node is to be the 1st in the list, // insert it before all other nodes. if (previousNode == NULL) { head = newNode; newNode-> = nodePtr; } else { previousNode->next = newNode; newNode->next = nodePtr; } } } Continued from previous slide.
  • 25. Program: 3 25 // 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(); } 2.5 7.9 10.5 12.6 Output:
  • 26. 26 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. Stepping Through the Program 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.
  • 27. 27 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. 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.
  • 28. 28 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.
  • 29. 29 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…
  • 30. 30 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; } } Continued from previous slide.
  • 31. Program: 4 31 // 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(); cout << endl; Continued on next slide…
  • 32. 32 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(); } Continued from previous slide. 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.
  • 33. 33 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. Stepping Through the Program
  • 34. 34 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.
  • 35. 35 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. 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.
  • 36. Assignment: Variations of the Linked List 36 The Doubly-Linked List The Circular Linked List • Implementation of these two variations in C++ using OOP • Submit softcopy of your codes on [email protected] before Wednesday, Jan, 07. 3:00 PM