Data Structure and

Algorithm
Chapter Five

Linked List
Review of Pointers and Structures

• Pointer variables, which are often just called pointers, are

designed to hold memory addresses. With pointer variables you can
indirectly manipulate data stored in other variables.

• A statically allocated pointer declaration

int *ptr;

• A dynamically allocated pointer variable

ptr = new int;

• The expression, *ptr, denotes the memory cell to which ptr point
to.

• The & (address-of ) operator places the address of a variable into a

pointer variable p = &x;
Cont.
Cont.
Cont.

• Structure is a collection of data items and the data items can be

different data type. The data item of structure is called member of
the structure.

• Structure is defined using the struct keyword.

struct name {
data t ype1 member 1 ;
data t ype2 member 2
..
data t ype n member
n;
};
Cont.
E.g. struct Time{
int hour;
int minute;
int second;
};

• Structure variables are

declared like variables of other
types.

• Syntax: struct <structure tag>

<variable name>;

E.g. struct Time timeObject,

Cont.

• Members of a structure are accessed using two ways.

• The Dot operator (.): to access data members of structure variables.

• The Arrow operator (->): to access data members of pointer variables

pointing to the structure.

• E.g. Print member hour of timeObject and timeptr.

cout<< timeObject.hour; or

cout<<timeptr->hour;

• timeptr->hour is the same as

(*timeptr).hour.
Cont.
• Structures can hold pointers to instances of themselves, are called self
referential structures.
struct list{
char name[10];
int count;
list *next;
};

• This is the only case in C++ where you are allowed to refer to a data
type (in this case list) before you have even finished defining it!

• However, structures cannot contain instances of themselves.

Introduction to Linked Lists
• Linked lists are the most basic self-referential structures. Linked lists

allow you to have a chain of structs with related data.

• A linked list is made up of a chain of nodes. Each node contains:

– The data item, and

– A pointer to the next node

• A linked list is a data structure that is built from structures and

pointers. It forms a chain of "nodes" with pointers representing the
links of the chain and holding the entire thing together.
Array Vs. Linked list

• Arrays are simple but we must specify their size at construction time.
This has its own drawbacks.

• If you construct an array with space for n, tomorrow you may need
n+1. Here comes a need for a more flexible system.

• Linked list- Flexible space use by dynamically allocating space for

each element as needed.

• This implies that one need not know the size of the list in advance.
Memory is also efficiently utilized.
 Cont.
Array Linked Lists
 Physically Contiguous  Logically Contiguous Only
 Fixed Length  Changeable Length
 Direct access  Sequential Access
 Cost of access =O(1)  Cost of access =O(n)
 Memory utilization= not efficient  Memory utilization= efficient
 Memory requirement=less  Memory requirement=high
 Linear and binary search=O(logN)  Linear and binary search=O(N)
Types of Linked Lists
• Singly Linked List: In a singly linked list, each node has only one
pointer, commonly called “next” since it points to the next node in
the sequence. The first node is called the “head” of the list. The last
node in the list points to NULL.

• Circular Linked List: A singly linked list can become a circular

node by assigning the address of the head node to the tail node
instead of NULL. This illustrates the flexibility of this data structure.
Cont.

• A doubly linked list: has two pointer variables, one pointing forward
to the next node and one pointing back to the previous node.
Singly Linked Lists
Creating Linked Lists in C++

• A linked list is a data structure that is built from structures and

pointers. It forms a chain of "nodes" with pointers
representing the links of the chain and holding the entire thing
together. A linked list can be represented by a diagram like this
one:
Cont.

• This linked list has four nodes in it, each with a link to the next
node in the series.

• The last node has a link to the special value NULL, which any
pointer (whatever its type) can point to, to show that it is the
last link in the chain.

• There is also another special pointer, called Start (also called

head), which points to the first link in the chain so that we can
keep track of it.
Defining the data structure for a linked list

• The key part of a linked list is a structure, which holds the

data for each node (the name, address, age or whatever for the
items in the list), and, most importantly, a pointer to the
next node.
• Here we have given the structure of a typical node:
struct node {
char name[20]; // Name of up to 20 letters
int age
float height; // In metres
node *nxt;// Pointer to next node
};
node *start_ptr = NULL;
Cont.
• The important part of the structure is the line before the closing
curly brackets. This gives a pointer to the next node in the list.
• This is the only case in C++ where you are allowed to refer to a
data type (in this case node) before you have even finished
defining it!
• We have also declared a pointer called start_ptr that will
permanently point to the start of the list.
• To start with, there are no nodes in the list, which is why
start_ptr is set to NULL.
Adding a node to the list

• The first problem that we face is how to add a node to the list.

• For simplicity's sake, we will assume that it has to be added to

the end of the list, although it could be added anywhere in the
list (a problem we will deal with later on).

• First, we declare the space for a pointer item and assign a

temporary pointer to it. This is done using the new statement as
follows:
node *temp;
temp
temp = new node;
Cont.
• We can refer to the new node as *temp, i.e. "the node that
temp points to". When the fields of this structure are referred
to, brackets can be put round the *temp part, as otherwise the
compiler will think we are trying to refer to the fields of the
pointer. Alternatively, we can use the arrow pointer notation.
cout << "Please enter the name of the person: ";
cin >> temp->name;
cout << "Please enter the age of the person : ";
cin >> temp->age;
cout << "Please enter the height of the person : ";
cin >> temp->height;
temp->next = NULL;
Cont.
• The last line sets the pointer from this node to the next to NULL,
indicating that this node, when it is inserted in the list, will be the last
node.

• Having set up the information, we have to decide what to do with the

pointers.

• Of course, if the list is empty to start with, there's no problem - just

set the Start pointer to point to this node (i.e. set it to the same
value as temp):

if (start_ptr == NULL)

start_ptr = temp;
Cont.
• It is harder if there are already nodes in the list. In this case, the secret

is to declare a second pointer, temp2, to step through the list until it

finds the last node.

node *temp2;
temp2 = start_ptr; // We know this is not NULL - list not empty!
while (temp2->next != NULL)
{ temp2 = temp2->next; // Move to next link in chain }

• The loop will terminate when temp2 points to the last node in the

chain, and it knows when this happens because the next pointer in

that node will point to NULL. When it has found it, it sets the pointer

from that last node to point to the node we have just declared:
Cont.
temp2->next = temp;

• The link temp2->nxt in this diagram is the link joining the last two
nodes.

• The full code for adding a node at the end of the list is shown below,
in its own function:
void add_node_at_end () {
node *temp, *temp2; // Temporary pointers
temp = new node; // Reserve space for new node and fill it with data
cout << "Please enter the name of the person: ";
cin >> temp->name;
cout << "Please enter the age of the person : ";
cin >> temp->age;
cout << "Please enter the height of the person : ";
cin >> temp->height;
temp->nxt = NULL; // Set up link to this
node
if (start_ptr == NULL)
start_ptr = temp;
else {
temp2 = start_ptr; != NULL) {
while (temp2->nxt // We
know this is not NULL - list not empty!
temp2 = temp2->nxt; // Move to next link in chain
}
temp2->nxt = temp;
}
}
Adding at some position
• ?????????????????
Displaying the list of nodes
• Having added one or more nodes, we need to display the list of nodes
on the screen. This is comparatively easy to do. Here is the method:

1. Set a temporary pointer to point to the same thing as the start

pointer.

2. If the pointer points to NULL, display the message "End of list"

and stop.

3. Otherwise, display the details of the node pointed to by the start

pointer.

4. Make the temporary pointer point to the same thing as the next
pointer of the node it is currently indicating.
Cont.
• The temporary pointer moves along the list, displaying the details
of the nodes it comes across. At each stage, it can get hold of the next
node in the list by using the next pointer of the node it is currently
pointing to. Here is the C++ code that does the job:
temp = start_ptr;
do {
if (temp ==
NULL)
cout <<
"End of
list" <<
endl;
else { // Display details for what temp
points to cout << "Name : " << temp->name <<
endl;
cout << "Age : " << temp->age << endl;
Navigating through the List
• One thing you may need to do is to navigate through the list, with a pointer
that moves backwards and forwards through the list, like an index pointer in
an array. This is certainly necessary when you want to insert or delete a node
from somewhere inside the list, as you will need to specify the position.

• We will call the mobile pointer current. First of all, it is declared, and set to
the same value as the start_ptr pointer:

node *current;

current = start_ptr;

• Notice that you don't need to set current equal to the address of the start
pointer, as they are both pointers. The statement above makes them both
point to the same thing:
Cont.
• It's easy to get the current pointer to point to the next node in the list
(i.e. move from left to right along the list).

current = current->next;

• In fact, we had better check that it isn't pointing to the last item in the
list. If it is, then there is no next node to move to:

if (current->next == NULL)

cout << "You are at the end of the list." << endl;

else

current = current->next;
Cont.

• Moving the current pointer back one step is a little harder. This is
because we have no way of moving back a step automatically from
the current node.

• The only way to find the node before the current one is to start at the
beginning, work our way through and stop when we find the node
before the one we are considering at the moment.

• We can tell when this happens, as the next pointer from that node
will point to exactly the same place in memory as the current pointer
(i.e. the current node).
Cont.
Previous Current
Start
Stop here

NULL

• First of all, we had better check to see if the current node is also not the

first one. If it is, then there is no "previous" node to point to.

• If not, check through all the nodes in turn until we detect that we are just

behind the current one.

Cont.
if (current == start_ptr)
cout << "You are at the start of the list" << endl;
else {
node *previous; // Declare the
pointer previous = start_ptr;
while (previous->next != current)
{ previous = previous-
>next; } current = previous;
}
• The else clause translates as follows: Declare a temporary pointer (for use in
this else clause only). Set it equal to the start pointer. All the time that it is
not pointing to the node before the current node, move it along the line. Once
the previous node has been found, the current pointer is set to that node - i.e.
it moves back along the list.
Cont.
• Now that you have the facility to move back and forth, you need to
do something with it.

• we can alter the details for that particular node in the list:
cout << "Please enter the new name of the person: ";
cin >> current->name;
cout << "Please enter the new age of the person : ";
cin >> current->age;
cout << "Please enter the new height of the person :
";
cin >> current->height;
Deleting a node from the List
• When it comes to deleting nodes, we have three choices: Delete a
node from the start of the list, delete one from the end of the list, or
delete one from somewhere in the middle.
• When a node is deleted, the space that it took up should be reclaimed.
Otherwise the computer will eventually run out of memory space. This is
done with the delete instruction:
delete temp; // Release the memory pointed to by temp
• However, we can't just delete the nodes directly as it would break the
chain. We need to reassign the pointers and then delete the node at the
last moment.
Deleting the First node in the List
• Here is how we go about deleting the first node in the linked list:

temp = start_ptr; // Make the temporary pointer

// identical to the start pointer
• Now the first node has been safely tagged so that we can refer to it even
when the start pointer has been reassigned
Cont.
• we can now move the start pointer to the next node in the chain:
start_ptr = start_ptr->nxt; // Second node in
chain.

delete temp; // Wipe out original start node

Cont.
• Here is the function that deletes a node from the start:
void delete_start_node()
{
node *temp;
temp = start_ptr;
start_ptr = start_ptr->nxt;
delete temp;
}
Deleting the Last node in the List
• Deleting a node from the end of the list is harder, as the temporary
pointer must find where the end of the list is by hopping along
from the start.
• This is done using code that is almost identical to that used to insert
a node at the end of the list.
• It is necessary to maintain two temporary pointers, temp1 and
temp2. The pointer temp1 will point to the last node in the list
and temp2 will point to the previous node.
• We have to keep track of both as it is necessary to delete the last
node
and immediately afterwards, to set the nxt pointer of the previous
node to NULL (it is now the new last node).
Cont.
• Here is the method.
1.Look at the start pointer. If it is NULL, then the list is empty, so print out a "No
nodes to delete" message.
2. Make temp1 point to whatever the start pointer is pointing to.
3.If the nxt pointer of what temp1 indicates is NULL, then we've found the last node of
the list, so jump to step 7.
4. Make another pointer, temp2, point to the current node in the list.
5. Make temp1 point to the next item in the list.
6. Go to step 3.
7.If you get this far, then the temporary pointer, temp1, should point to the last item in
the list and the other temporary pointer, temp2, should point to the last-but-one item.
8. Delete the node pointed to by temp1.
9.Mark the nxt pointer of the node pointed to by temp2 as NULL. it is the new last
node.
Cont.
• Let’s see it with a drawing.

• The start pointer doesn't point to NULL, so we don't have to display a

“No nodes to delete" message. Let's get straight on with step2 - set
the pointer temp1 to the same as the start pointer:
Cont.
• The next pointer from this node isn't NULL, so we haven't found the
end node. Instead, we set the pointer temp2 to the same node as
temp1

• and then move temp1 to the next node in the list:

Cont.
• Going back to step 3, we see that temp1 still doesn't point to the last node
in the list, so we make temp2 point to what temp1 points to

start_ptr

NULL

temp 2

temp1

• and temp1 is made to point to the next node

along:
Cont.
• Eventually, this goes on until temp1 really is pointing to the last node
in the list, with temp2 pointing to the penultimate node:

• Now we have reached step 8. The next thing to do is to delete the

node pointed to by temp1
Cont.
• and set the nxt pointer of what temp2 indicates to NULL:

• Here is a function that deletes the last

node:
Cont. void delete_end_node()
{
node *temp1, *temp2;
if (start_ptr == NULL)
cout <<
"The list
is empty!"
<< endl;
else
{
temp1 =
start_ptr;
if (temp1-
>nxt ==
NULL)
{
delete temp1;
start_ptr = NULL;
}
else
{
while (temp1->nxt
!= NULL)
{
temp2 = temp1;
temp1 = temp1->nxt;
Deleting a node somewhere in the middle

• First, you will need to check weather the list is empty or not.
• Second, if the list has only one node, you need to see if that
node is the node you want to delete.
• Third, you will need to navigate through the list until you find
the node you want to delete.
• Fourth, you will need to assign the next pointer of the
previous node to the node after the one you want to delete.
• Finally you delete the node.
EX

• Write a C++ Program that implements the above concept (

Deleting somewhere in the middle)
Doubly Linked List
Introduction
•If you've mastered how to do singly linked lists, then it shouldn't
be much of a leap to doubly linked lists
• A doubly linked list is one where there are links from each node
in
both directions:

•You will notice that each node in the list has two pointers, one to
the next node and one to the previous one - again, the ends of the
list are defined by NULL pointers.
Cont.

• Also there is no pointer to the start of the list. Instead, there is

simply a pointer to some position in the list that can be moved left
or right.

• The reason we needed a start pointer in the ordinary linked list

is because, having moved on from one node to another, we can't
easily move back, so without the start pointer, we would lose track
of all the nodes in the list that we have already passed.

• With the doubly linked list, we can move the current pointer
backwards and forwards at will.
Creating Doubly Linked Lists
• The nodes for a doubly linked list would be defined as follows:
struct node{
char name[20];
node *nxt; // Pointer to next node
node // Pointer to previous node
*prv;
};node *current;
node *head; // Pointer to tag the first
node node *tail; // Pointer to tag the last
node
current = new node;
strcpy(current->name, "Fred“);
head= current;
tail = current;
current->nxt = NULL;
Cont.
• We have also included some code to declare the first node and set its
pointers to NULL. It gives the following situation:

• We still need to consider the directions 'forward' and 'backward', so

in this case, we will need to define functions to add a node to the
start of the list (left-most position) and the end of the list (right-most
position).
Adding a Node to a Doubly Linked list
• Adding a node at the start of a doubly linked list

void add_node_at_start () {
// Declare a temporary pointer and move it to current
node *temp = current;
if(temp==NULL){
node *temp1; temp1= new
node;
cout<<"enter name"<<endl;
cin>>temp1->name ;
current=temp1;
current->nxt = NULL; current-
>prv = NULL; head=
current;
tail = current;
}
 else{

while (temp->prv != NULL)

temp = temp->prv; // Declare a new node and link it in
node *temp2;
temp2 = new node;
cout<<"enter name"<<endl;
cin>>temp2->name ; // Store the new name in the node
temp2->prv = NULL; // This is the new start of the list
temp2->nxt = temp; // Links to current list
temp->prv = temp2;
head = temp2; //make head point to the first
node
}
}
 Cont.
• The method for adding a node to the right-most end of the list is similar
for adding a node at the other end. First, a temporary pointer is set up and
is made to march along the list until it points to last node in the list.

• After that, a new node is declared, and the name is accepted . The nxt
pointer of this new node is set to NULL to indicate that this node will be
the new end of the list. The prv pointer of the new node is linked into the
last node of the existing list. The nxt pointer of the current end of the list
is set to the new node.
Contd.
• Adding a node at the end of a doubly linked list

void add_node_at_end () {
// Declare a temporary pointer and move it to the
end
node *temp = current;
if(temp==NULL)
{
node *temp1;
temp1= new node;
cout<<"enter name"<<endl;
cin>>temp1->name ;
current=temp1;
current->nxt = NULL;
current->prv =
NULL; head=
current;
tail = current;
 else
{
while (temp->nxt != NULL)
temp = temp->nxt; // Declare a new node
and link it in node *temp2;
temp2 = new node;
cout<<"enter name"<<endl;
cin>>temp2->name ; // Store the new name in the node
temp2->nxt = NULL; // This is the new start of the list
temp2->prv = temp; // Links to current list
temp->nxt = temp2;
tail= temp2; //make tail point to the
last node
}
}
Displaying a Doubly Linked list
Displaying a doubly linked list forward

• Elements of a doubly linked list are displayed forward using the nxt
pointer to traverse forward and the head pointer to tag the first node.

void PrintForward(node* head)

{
node* temp = head;
if(temp==NULL)
cout<<"empity list"<<endl;
else{

while(temp!=NULL)
{
cout<<temp->name<< " ";
temp=temp->nxt;
}
cout<<endl;
}}
Contd.
Displaying a doubly linked list Backward

• Elements of a doubly linked list are displayed backward using the prv
pointer to traverse backward and the tail pointer to tag the last
node.

void PrintBackward(node* tail)

{
node* temp = tail;
if(temp==NULL)
cout<<"empity list"<<endl;
else{

while(temp!
=NULL)
{
cout<<temp-
>name<< " ";
Deleting a Node from a Doubly Linked list
Deleting a node from the start of a doubly linked list

• First you should check if the link is empty or not. Also if the link
has one or more than one element.

void delete_node_at_start ( ) {
// Declare a temporary pointer and move it to current
node *temp1 = current;
node *temp2;
if( temp1==NULL){
cout<<"empity list"<<endl;
}
else
{
if(temp1->prv == NULL && temp1->nxt == NULL )
{
current= NULL;
head= NULL;
tail=NULL;
delete temp1;

}
else{
while (temp1->prv != NULL)

{ temp2 = temp1;
temp1 = temp1->prv; }
delete temp1;
temp2->prv = NULL;
head = temp2;
//make head point to the first
node
}
Cont.
Deleting a node from the end of a doubly linked list

void delete_node_at_end ( ) {
// Declare a temporary pointer and move it to current
node *temp1 = current;
node *temp2;
if( temp1==NULL){
c
out<
<"e
mpit
y
list"
<<en
else
{
if(temp1->prv == NULL && temp1->nxt ==
NULL)
{
current= NULL;
head= NULL;
tail=NULL;
delete temp1;

}
else{
while (temp1->nxt != NULL)

{ temp2 = temp1;
temp1 = temp1->nxt; }
delete temp1;
temp2->nxt = NULL;
tail = temp2;
//make tail point to the last
node
Cont.
Deleting a node from the middle of a doubly linked list
void delete_middle_node() {
node *temp1, *temp2, temp3;
const int SIZE = 20;
char n[SIZE];
if (temp1 == NULL)
cout <<
"The list
is empty!"
<< endl;
else
{
cout << "Enter Name" << endl;
cin.ignore();
cin.getline(n, SIZE);
temp1 = head;
if (temp1->prv == NULL &&
temp1->nxt == NULL)
{
if(strcmp(t
emp1- }
else
{

cout << "The node is not found." << endl;

}
}
else
{
while (strcmp(temp1->name,n) !=0 && temp1->nxt != NULL)
{
temp2 = temp1;
temp1 = temp1->nxt;
}
if (temp1->nxt == NULL)
cout << "The node is not found!" << endl;
else{
temp3 =temp1->nxt;
temp2->nxt = temp1->nxt;
temp3->prv =temp2;
delete temp1;
}}
}
}
Reading
Assignment
• Read About Circular linked list and the operations on
it.
Assignment-1 (5%)

• Write a single C++ program that implements all the operations

on Singly linked list ( from creation to deletion)
 You have to use CLASS and STL

• Write a single C++ program that implements all the operations

on Doubly linked list ( from creation to deletion)
 You have to use CLASS and STL