Lab 03 Implementation of Circular Link List in C language

Objectives:

• To create the circular link list.

• To insert and traverse all node of circular link list.
• To solve classical Josephus problem
• To perform insertion and deletion of nodes
• To perform efficient memory usage through circular link list.

Introduction

In a circular linked list, the last node contains a pointer to the first node of the list. We can have a
circular singly linked list as well as a circular doubly linked list. While traversing a circular linked
list, we can begin at any node and traverse the list in any direction, forward or backward, until we
reach the same node where we started. Thus, a circular linked list has no beginning and no ending.
Figure 3.1 shows a circular linked list

Figure 3.1 Circular linked list

The only downside of a circular linked list is the complexity of iteration. Note that there are no
NULL values in the NEXT part of any of the nodes of list. Circular linked lists are widely used in
operating systems for task maintenance. We will now discuss an example where a circular linked
list is used. When we are surfing the Internet, we can use the Back button and the Forward button to
move to the previous pages that we have already visited. How is this done? The answer is simple. A
circular linked list is used to maintain the sequence of the Web pages visited. Traversing this
circular linked list either in forward or backward direction helps to revisit the pages again using
Back and Forward buttons. Actually, this is done using either the circular stack or the circular
queue. Consider Fig. 3.2. We can traverse the list until we find the NEXT entry that contains the
address of the first node of the list. This denotes the end of the linked list, that is, the node that
contains the address of the first node is actually Figure 3.2 Memory representation of a circular
linked list Linked Lists 181 the last node of the list. When we traverse the DATA and NEXT in this
manner, we will finally see that the linked list in Fig. 3.2 stores characters that when put together
form the word HELLO. Now, look at Fig. 3.3. Two different linked lists are simultaneously
maintained in the memory. There is no ambiguity in traversing through the list because each list
maintains a separate START pointer which gives the address of the first node of the respective
linked list.
 Figure 3.2 Memory representation

The remaining nodes are reached by looking at the value stored in NEXT. By looking at the figure,
we can conclude that the roll numbers of the students who have opted for Biology are S01, S03,
S06, S08, S10, and S11. Similarly, the roll numbers of the students who chose Computer Science
are S02, S04, S05, S07, and S09.

Figure 3.3 Memory representation of two circular

Pre Lab:

Task01: Inserting a New Node in a Circular Linked List

In this section, we will see how a new node is added into an already existing linked list.

We will take two cases and then see how insertion is done in each case.

Case 1: The new node is inserted at the beginning of the circular linked list.

Case 2: The new node is inserted at the end of the circular linked list.

Inserting a Node at the Beginning of a Circular Linked List

Consider the linked list shown in Fig. 3.4. Suppose we want to add a new node with data 9 as the
first node of the list. Then the following changes will be done in the linked list.

Figure 3.4 Inserting a new node at the beginning of a circular linked list

Figure 3.5 shows the algorithm to insert a new node at the beginning of a linked list. In Step 1, we
first check whether memory is available for the new node. If the free memory has exhausted, then
an OVERFLOW message is printed. Otherwise, if free memory cell is available, then we allocate
space for the new node. Set its DATA part with the given VAL and the NEXT part is initialized with
the address of the first node of the list, which is stored in START. Now, since the new node is added
as the first node of the list, it will now be known as the START node, that is, the START pointer
variable will now hold the address of the NEW_NODE. While inserting a node in a circular linked
list, we have to use a while loop to traverse to the last node of the list. Because the last node
contains a pointer to START, its NEXT field is updated so that after insertion it points to the new
node which will be now known as START.
 Figure 3.5 Algorithm to insert a new node at the beginning

Inserting a Node at the End of a Circular Linked List

Consider the linked list shown in Fig. 3.6. Suppose we want to add a new node with data 9 as the
last node of the list. Then the following changes will be done in the linked list.
 Figure 3.6 Inserting a new node at the end of a circular linked list

Figure 3.7 shows the algorithm to insert a new node at the end of a circular linked list. In Step 6, we
take a pointer variable PTR and initialize it with START. That is, PTR now points to the first node
of the linked list. In the while loop, we traverse through the linked list to reach the last node. Once
we reach the last node, in Step 9, we change the NEXT pointer of the last node to store the address
of the new node. Remember that the NEXT field of the new node contains the address of the first
node which is denoted by START.

Task02: Deleting a Node from a Circular Linked List

In this section, we will discuss how a node is deleted from an already existing circular linked list.
We will take two cases and then see how deletion is done in each case. Rest of the cases of deletion
are same as that given for singly linked lists.
Case 1: The first node is deleted.
Case 2: The last node is deleted.
Deleting the First Node from a Circular Linked List
Consider the circular linked list shown in Fig. 3.7. When we want to delete a node from the
beginning of the list, then the following changes will be done in the linked list.

Figure 3.7 Algorithm to insert a new node at the end

Deleting the First Node from a Circular Linked List Consider the circular linked list shown in Fig.
3.8. When we want to delete a node from the beginning of the list, then the following changes will
be done in the linked list.

Figure 3.8 Deleting the first node from a circular linked list
Deleting the Last Node from a Circular Linked List
Figure 3.9 shows the algorithm to delete the first node from a circular linked list. In Step 1 of the
algorithm, we check if the linked list exists or not. If START = NULL, then it signifies that there are
no nodes in the list and the control is transferred to the last statement of the algorithm. However, if
there are nodes in the linked list, then we use a pointer variable PTR which will be used to traverse
the list to ultimately reach the last node. In Step 5, we change the next pointer of the last node to
point to the second node of the circular linked list. In Step 6, the memory occupied by the first node
is freed. Finally, in Step 7, the second node now becomes the first node of the list and its address is
stored in the pointer variable START.

Figure 3.9 Algorithm to delete the first node

Consider the circular linked list shown in Fig. 3.10. Suppose we want to delete the last node from
the linked list, then the following changes will be done in the linked list.
Figure 3.11 shows the algorithm to delete the last node from a circular linked list. In Step 2, we take
a pointer variable PTR and initialize it with START. That is, PTR now points to the first node of the
linked list. In the while loop, we take another pointer variable PREPTR such that PREPTR always
points to one node before PTR. Once we reach the last node and the second last node, we set the
next pointer of the second last node to START, so that it now becomes the (new) last node of the
linked list. The memory of the previous last node is freed and returned to the free pool.
Figure 3.10 Deleting the last node from a circular linked list

Figure 3.11 Algorithm to delete the last node

In Lab
Task01: Write a program to create a circular linked list.
Task 02: Use the created circular linked list in task 01 to perform insertion and deletion at the
beginning and end of the list using code listing 01,02,03 and 04.
Task 03: Let say there is a group of soldiers surrounded by an overwhelming enemy force. There is
no hope for victory without reinforcement, but there is only a single horse available for escape. The
soldiers agree to a pact to determined which of them is to escape and summon help. They form a
circle and a number n is picked from a hat. One of their names is also picked from a hat. Beginning
with the soldier whose name is picked, they begin to count clockwise around the circle. When the
count reaches n, that soldier is removed from the circle, and the count begin again with the next
soldier. The process continues so that each time the counter reaches n, another soldier is remove
form the circle. Any soldier removed from the circle is no longer counted. The last soldier
remaining is to take the horse and escape. The problem is , given number n, the ordering of the
soldiers in the circle, and the soldier from whom the count begins, to determine the order in which
soldiers are eliminated from the circle and which soldier escapes.
The input to program is the number n and list of names which is clockwise ordering of circle,
beginning with the soldier form whom the count is to start. The last input line contains the string
“end” indicating the end of the input. The program should print the names in order that they are
eliminated and the name of the soldier who escapes.
Post Lab Task: Complete the task 02 of in lab as your post lab.