This document discusses linked lists and their implementation. It begins by defining a list as a sequence of zero or more elements of a given type that can be linearly ordered. Linked lists are introduced as a flexible data structure that uses nodes connected by pointers to dynamically allocate elements in memory. The key operations on linked lists are described, including appending, traversing, inserting, deleting nodes. Code examples are provided to implement these operations using a ListNode struct containing a data element and pointer to the next node. Functions like appendNode and displayList are demonstrated, with appendNode adding to the end of the list and displayList traversing the list to output each element.
2D array in C++ language ,define the concept of c++ Two-Dimensional array .with example .and also Accessing Array Components concept.and Processing Two-Dimensional Arrays.
presentation about bubble sort
presented by: Ahmed al-butty
Arab Open University - Riyadh , Saudi Arabia
the content
Introduction to Sorting Algorithms
What is Bubble Sort
Bubble Sort Algorithm
Example of Bubble Sort
Complexity Analysis
When to Choose Bubble Sort
In computer science, a linked list is a linear collection of data elements, in which linear order is not given by their physical placement in memory. Instead, each element points to the next
2D array in C++ language ,define the concept of c++ Two-Dimensional array .with example .and also Accessing Array Components concept.and Processing Two-Dimensional Arrays.
presentation about bubble sort
presented by: Ahmed al-butty
Arab Open University - Riyadh , Saudi Arabia
the content
Introduction to Sorting Algorithms
What is Bubble Sort
Bubble Sort Algorithm
Example of Bubble Sort
Complexity Analysis
When to Choose Bubble Sort
In computer science, a linked list is a linear collection of data elements, in which linear order is not given by their physical placement in memory. Instead, each element points to the next
ccvcvbcbvcbvcbvcbvcb vngfg hgjhg gj jgjhgjhgjhg jhgh jhgjhgj gjhgjhgjhgjhgjhgjhgjhg jghgjhgjhgjhgjhg jjghjhgjhgjhgjhgjh hgjhgjhgjhgjhgjhgjhgjgjhgjhgjhg hgfgfhdfhtftfj jgyjyyyugyugyug yjgghgjhgjhf drdfhgfgfgfgj jgjhgjhgjhgjhgjhg jhgghjfgf fxdx gfd hdhfd tftyf yytfy ytftyf ytf ytfty fytftykgh kghjg jhghgh fgfghfgh fgfghfgf gfgfgfgfytf hgfggf ghfgfg gjhghjg cfffgh jgfgfhgffhg hghh yuy ygyyuyutyutyu jgfghfhgfghfh fghfhgfhgf fthfhfhf hfhfhgf hfhgfghf fghfghfghfhhgfghf jgjhgjhgjhgjhgjhgj jgjhgjh jgjhg jgjhgjhgjhg jhgjhgjhg jhgjhg jhgjhgollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read more ollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read moreollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read moreollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read moreollowing the announcement of Google+ API deprecation scheduled for March 2019, a nu
Introduction to AI for Nonprofits with Tapp NetworkTechSoup
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
2024.06.01 Introducing a competency framework for languag learning materials ...Sandy Millin
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
Francesca Gottschalk - How can education support child empowerment.pptxEduSkills OECD
Francesca Gottschalk from the OECD’s Centre for Educational Research and Innovation presents at the Ask an Expert Webinar: How can education support child empowerment?
Safalta Digital marketing institute in Noida, provide complete applications that encompass a huge range of virtual advertising and marketing additives, which includes search engine optimization, virtual communication advertising, pay-per-click on marketing, content material advertising, internet analytics, and greater. These university courses are designed for students who possess a comprehensive understanding of virtual marketing strategies and attributes.Safalta Digital Marketing Institute in Noida is a first choice for young individuals or students who are looking to start their careers in the field of digital advertising. The institute gives specialized courses designed and certification.
for beginners, providing thorough training in areas such as SEO, digital communication marketing, and PPC training in Noida. After finishing the program, students receive the certifications recognised by top different universitie, setting a strong foundation for a successful career in digital marketing.
Macroeconomics- Movie Location
This will be used as part of your Personal Professional Portfolio once graded.
Objective:
Prepare a presentation or a paper using research, basic comparative analysis, data organization and application of economic information. You will make an informed assessment of an economic climate outside of the United States to accomplish an entertainment industry objective.
Acetabularia Information For Class 9 .docxvaibhavrinwa19
Acetabularia acetabulum is a single-celled green alga that in its vegetative state is morphologically differentiated into a basal rhizoid and an axially elongated stalk, which bears whorls of branching hairs. The single diploid nucleus resides in the rhizoid.
Synthetic Fiber Construction in lab .pptxPavel ( NSTU)
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
A Strategic Approach: GenAI in EducationPeter Windle
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
2. 2
List
A Flexible structure, because can grow
and shrink on demand.
Elements can be:
Inserted
Accessed
Deleted
At any position
3. 3
List
Lists can be:
Concatenated together.
Split into sublists.
Mostly used in Applications like:
Information Retrieval
Programming language translation
Simulation
4. 4
List
A List is a sequence of zero or more
elements of a given type (say
elementtype)
Represented by a comma-separated
sequence of elements:
a1, a2,…an
Where,
n >= 0 and each ai is of type
elementtype.
5. 5
List
if n>= 1,
a1 is the first element
an is the last element
if n = 0,
we have an empty list
6. 6
List
The elements of a list can be linearly ordered.
⇒ai precedes ai+1 for i = 1,2,3…n-1
ai follows ai-1 for i = 2,3,4…n
The element ai is at position i.
END(L) will return the position following
position n in an n-element list L.
Position END(L) has a varying distance as the
list grows and shrinks, all other positions
have a fixed distance from the beginning of
the list.
7. 7
Common Operations on List ADT
1. INSERT(x,p,L): Insert x at position p in list L. If
list L has no position p, the result is undefined.
2. LOCATE(x,L): Return the position of x on list
L.
3. RETRIEVE(p,L): Return the element at
position p on list L.
4. DELETE(p,L): Delete the element at position p
on list L.
5. NEXT(p,L): Return the position following p on
list L.
8. 8
Common Operations on List ADT
6. PREVIOUS(p,L): Return the position
preceding position p on list L.
7. MAKENULL(L): Causes L to become an
empty list and returns position END(L).
8. FIRST(L): Returns the first position on the list
L.
9. PRINTLIST(L): Print the elements of L in order
of occurrence.
9. 9
Implement a Linked Structure Using an Array
1 3 4 10
I data[I] next[I]
0 3 6
1 * *
2 1 0
3 10 -1
4 * *
5 * *
6 4 3
Need a start link.
start
end
How to insert,
delete, and
append?
10. 10
Linked Structure Using an Array
With a free list
1 3 4 10
I data[I] next[I]
0 3 6
1 * 4
2 1 0
3 10 -1
4 * -1
5 * 1
6 4 3
Data_start
end
Free list
Free_start
11. 11
Linked Structure Using an Array
I data[I] next[I]
0 * 6
1 * 4
2 * 0
3 * 5
4 * -1
5 * 1
6 * 3
Free_start
end
Free list
12. 12
Linked Lists
Pointer Based Implementation of Linked List ADT
Dynamically allocated data structures can be linked together to form
a chain.
A linked list is a series of connected nodes (or links) where each
node is a data structure.
A linked list can grow or shrink in size as the program runs.
This is possible because the nodes in a linked list are dynamically
allocated.
13. 13
If new information needs to be added to the list, the program -
a) Allocates another node
b) Inserts it into the series.
If a piece of information is to be deleted from the list, the program -
a) Deletes the node containing the information
Advantages of Linked Lists over Arrays
Linked lists are more complex to code and manage than arrays,
but they have some distinct advantages.
a) A linked list can easily grow and shrink in size.
14. 14
(The programmer doesn’t need to know how many nodes will be
in the list. They are created in memory as needed).
b) Speed of insertion or deletion from the list.
e.g. with an array, to insert an element, requires all elements beyond
the insertion point to be moved forward one position to make room
for the new element.
Similarly, to delete an element, requires all elements after
the insertion point to be moved back one position to close the gap.
When a node is inserted, or deleted from a linked list, none of the
other nodes have to be moved!!!!
15. 15
Composition of a Linked List
Each node in the linked list contains -
a) One or more members that represent data (e.g. inventory records,
customer names, addresses, telephone numbers, etc).
b) A pointer, that can point to another node.
Data Members Pointer
16. 16
A linked list is called “linked” because each node in the series
(i.e. the chain) has a pointer to the next node in the list, e.g.
List Head
NULL
a) The list head is a pointer to the first node in the list.
b) Each node in the list points to the next node in the list.
c) The last node points to NULL (the usual way to signify the end).
Note, the nodes in a linked list can be spread out over the memory.
17. 17
Declarations
How to declare a linked list in C++?
Step 1) Declare a data structure for the nodes.
e.g. the following struct could be used to create a list where each
node holds a float -
struct ListNode
{
float value;
ListNode *next;
};
18. 18
a) The first member of the ListNode struct is a float called value.
It is to hold the node’s data.
b) The second member is a pointer called next.
It is to hold the address of any object that is a ListNode struct.
Hence each ListNode struct can point to the next one in the list.
The ListNode struct contains a pointer to an object of the same type
as that being declared. It is called a self-referential data structure.
This makes it possible to create nodes that point to other nodes of
the same type.
19. 19
Step 2) Declare a pointer to serve as the list head, e.g
ListNode *head;
Before you use the head pointer, make sure it is initialized to NULL,
so that it marks the end of the list.
Once you have done these 2 steps (i.e. declared a node data structure,
and created a NULL head pointer, you have an empty linked list.
The next thing is to implement operations with the list.
Linked List Operations
There are 5 basic linked list operations -
20. 20
1) Appending a node
2) Traversing a list
3) Inserting a node
4) Deleting a node
5) Destroying the list
We will implement this Linked List ADT (abstract data type) that
performs basic linked list operations using the ListNode structure and
head pointer declared earlier. We use the following class
declaration -
class FloatList
{
private:
// Declare a structure for the list
struct ListNode
{
float value;
struct ListNode *next;
};
ListNode *head; // List head pointer
21. 21
public:
FloatList(void) // Constructor
{ head = NULL; }
~FloatList(void); // Destructor
void appendNode(float);
void insertNode(float);
void deleteNode(float);
void displayList(void);
};
Note, the constructor initializes the head pointer to NULL,
establishing an empty linked list.
The class has members to append, insert, delete and display (all)
nodes.
The destructor destroys the list by deleting all its nodes.
22. 22
We now examine these functions individually -
1) Appending a Node to the List
To append a node to a linked list, means adding it to the end of the list.
The appendNode member function accepts a float argument, num.
The function will -
a) allocate a new ListNode structure
b) store the value in num in the node’s value member
c) append the node to the end of the list
This can be represented in pseudo code as follows-
23. 23
a) Create a new node.
b) Store data in the new node.
c) 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.
The actual C++ code for the above pseudo code is -
24. 24
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 = 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;
}
}
25. 25
We examine this important piece of code in detail.
The function declares the following local variables -
ListNode *newNode, *nodePtr;
a) The newNode pointer will be used to allocate and point to the new
node.
b) The nodePtr pointer will be used to travel down the linked list,
looking for the last node.
The next few statements -
i) create a new node
ii) store num in its value member.
26. 26
newNode = new ListNode;
newNode->value = num;
newNode->next = NULL;
The last statement above is important. This node will become the
last node in the list, so its next pointer must point to NULL.
Now test the head pointer to see if there are any nodes already
in the list. If head points to NULL, we make the new node the
first in the list.
Do this by making head point to the new node, i.e.
if(!head)
head = newNode;
27. 27
But, if head does not point to NULL, then there must already
be nodes in the list.
The else part must then contain code to -
a) Find the end of the list
b) Insert the new node.
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;
}
28. 28
The code uses nodePtr to travel down the list. It does this by
assigning nodePtr to head.
nodePtr = head;
A while loop is then used to traverse (i.e. travel through) the list,
looking for the last node (that will have its next member pointing
to NULL).
while(nodePtr->next)
nodePtr = nodePtr->next;
Now the nodePtr is pointing to the last node in the list, so make its
next member point to newNode.
nodePtr->next = newNode;
29. 29
This appends newNode at the end of the list.
Remember, newNode->next already points to
NULL.
// 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.)
30. 30
We step through the above program, observing how the appendNode
function builds a linked list to store the 3 argument values.
The head pointer is automatically initialized to 0 (NULL), indicating
the list is empty.
The first call to appendNode passes 2.5 as the argument.
A new node is allocated in memory.
2.5 is copied into its value member, and NULL is assigned to its
next pointer.
31. 31
newNode = new ListNode;
newNode->value = num;
newNode->next = NULL;
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.
Since head points to NULL, then the condition !head is true, so
the statement, head = newNode is executed, making newNode
the first node in the list.
32. 32
There are no more statements to execute, so control returns to the
function main.
In the second call to appendNode, 7.9 is passed as the argument.
Again, the first 3 statements create a new node, which stores the
argument in the node’s value member, and assigns its next pointer
to NULL. Visually this is -
33. 33
Since head no longer points to NULL, the else part of the if statement
is executed.
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;
}
The first statement in the else block assigns the value in head
to nodePtr. So, nodePtr and head point to the same node.
34. 34
Look now at the next member of the node that nodePtr points at.
Its value is NULL, so nodePtr->next also points to NULL.
So, nodePtr is already at the end of the list, so the while loop
terminates.
The last statement, nodePtr->next = newNode, causes
nodePtr->next to point to the new node. This appends newNode to
the end of the list, as shown -
35. 35
The third time appendNode is called, 12.6 is passed as argument.
Again, the first 3 statements create a node with the argument stored
in the value member.
Now, the else part of the if statement executes. Again nodePtr is
made to point to the same node as head.
36. 36
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 appends newNode
to the end of the list, as shown -
37. 37
The above is the final state of the linked list.
2) Traversing a Linked List
The previous function appendNode, used a while loop that
traverses, or travels through the linked list.
We now demonstrate the displayList member function, that
traverses the list, displaying the value member of each node.
38. 38
The following pseudocode represents the algorithm -
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.
The actual C++ code is -
40. 40
// 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();
}
Program 17-2 Output
2.5
7.9
12.6
41. 41
Usually, when an operation is performed on some or all of the nodes
in a linked list, a traversal algorithm is used.
We will see variations of this traversal algorithm used throughout
this chapter.
3) Inserting a Node
Inserting a node in the middle of a list is more complicated than
appending a node.
Assume all values in the list are sorted, and you want all new values
to be inserted in their proper position (preserving the order of the
list).
We use the same ListNode structure again, with pseudo code.
42. 42
This pseudocode shows the algorithm to find the new node’s
proper position in the list, and inserting it there.
It is assumed the nodes already in the list are ordered.
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.
43. 43
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.
44. 44
The new algorithm finds the first node whose value is greater than
or equal to the new value.
The new node is then inserted before the found node.
This requires two pointers during the traversal -
a) One to point to the node being inspected
b) The other to point to the previous node.
The code above shows this traversal algorithm.
Num holds the value being inserted into the list.
45. 45
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;
The code below uses the pointers nodePtr and previousNode.
previousNode always points to the node before the one pointed to by
nodePtr. The entire insertNode function is shown below.
46. 46
// Skip all nodes whose value member is less
// than num.
while (nodePtr != NULL && nodePtr->value < num)
{
previousNode = nodePtr;
} nodePtr = nodePtr->next;
// If the new mode 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;
}
}
}
47. 47
// 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();
}
48. 48
Program Output
2.5
7.9
10.5
12.6
As in previous program, this program calls the appendNode function 3
times to build the list with the values 2.5, 7.9, 12.6
The insertNode function is called with argument 10.5
In insertNode, the new node is created, and the function argument
is copied to its value member.
49. 49
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, i.e.
Since nodePtr is not NULL, and nodePtr->value is less than num,
the while loop will iterate.
During the iteration, previousNode is made to point to the node
that nodePtr is pointing to. nodePtr is then advanced to point to
the next node. i.e.
50. 50
The loop does its test once more. Since nodePtr is not NULL, and
nodePtr->value is less than num, the loop iterates a second time.
During the second iteration, both previousNode and nodePtr are
advanced by one node in the list, i.e.
51. 51
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, i.e.
52. 52
This leaves the list in its final state. The nodes (you will see if
you follow the links from the head pointer to NULL) are stored
in the order of their value members.
Deleting a Node
This requires 2 steps -
a) Remove the node from the list without breaking the links
created by the next pointers.
b) Delete the node from memory.
53. 53
The deleteNode member function searches for a node with a
particular value and deletes it from the list.
It uses an agorithm similar to the insertNode function.
The two node pointers nodePtr and previousPtr are used to
traverse the list (as before).
When nodePtr points to the node to be deleted, previousNode->next
is made to point to nodePtr->next.
This removes the node pointed to by nodePtr from the list.
The final step is to free the memory used by the node using the
delete operator.
54. 54
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;
}
else
{
// Initialize nodePtr to head of list
nodePtr = head;
55. 55
// 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;
}
}
// This program demonstrates the deleteNode member function
#include <iostream.h>
#include "FloatList.h“
void main(void)
{
FloatList list;
56. 56
// 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;
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();
}
57. 57
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.
58. 58
To show how deleteNode works, we do a step through of the call
to delete the node with value 7.9
Look at the else part of the 2nd if statement. It is here the function
does its thing, since the list is not empty, and the first node does
not contain 7.9
The node pointers nodePtr and previousPtr are used to traverse the
list (as with the insertNode function).
The while loop terminates when the value 7.9 is found. When this
happens the list and other pointers are in the following state -
59. 59
Then the following statement executes -
previousNode->next = nodePtr->next;
This causes the links in the list to bypass the node that nodePtr
points to.
The node still exists in memory, but it is removed from the list.
60. 60
The bypassed node is destroyed with the statement delete nodePtr;
Destroying the List
Use the class’s destructor to release all the memory used by the list.
It does this by stepping through the list, deleting each node, one by one.
61. 61
FloatList::~FloatList(void)
{
ListNode *nodePtr, *nextNode;
nodePtr = head;
while (nodePtr != NULL)
{
nextNode = nodePtr->next;
delete nodePtr;
nodePtr = nextNode;
}
}
Note 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.