Contact No : 7600044051
--------------------------------------------------------------------------------------------------------------------------
Single Linked List
What is Linked List?
When we want to work with
unknown number of data values, we use a linked list data structure to organize
that data. Linked list is a linear data structure that contains sequence of
elements such that each element links to its next element in the sequence. Each
element in a linked list is called as "Node".
What is Single Linked
List?
Simply a list is a
sequence of data, and linked list is a sequence of data linked with each other.
The formal definition of
a single linked list is as follows...
Single
linked list is a sequence of elements in which every element has link to its
next element in the sequence.
In any single linked
list, the individual element is called as "Node". Every "Node" contains two fields, data and next. The data field is used to store actual value of
that node and next field is used to store the address of the next node in the
sequence.
The graphical representation of a node in a single
linked list is as follows...
NOTE
☀
In a single linked list, the address of the first node is always stored in a
reference node known as "front" (Some times it is also known as
"head").
☀ Always next part (reference part) of the last node must be NULL.
☀ Always next part (reference part) of the last node must be NULL.
Example
Operations
In a single linked list
we perform the following operations...
1.
Insertion
2.
Deletion
3.
Display
Before we implement
actual operations, first we need to setup empty list. First perform the
following steps before implementing actual operations.
- Step 1: Include
all the header files which are used in the program.
- Step 2: Declare
all the user defined functions.
- Step 3: Define
a Node structure with two members data and next
- Step 4: Define
a Node pointer 'head'
and set it to NULL.
- Step 5: Implement
the main method by displaying operations
menu and make suitable function calls in the main method to perform user
selected operation.
Insertion
In a single linked list,
the insertion operation can be performed in three ways. They are as follows...
1.
Inserting At Beginning of the list
2.
Inserting At End of the list
3.
Inserting At Specific location in the list
Inserting
At Beginning of the list
We can use the following
steps to insert a new node at beginning of the single linked list...
- Step 1: Create
a newNode with given value.
- Step 2: Check
whether list is Empty (head == NULL)
- Step 3: If
it is Empty then, set newNode→next = NULL
and head = newNode.
- Step
4: If
it is Not Empty then, set newNode→next = head and head =
newNode.
Inserting
At End of the list
We can use the following
steps to insert a new node at end of the single linked list...
- Step 1: Create
a newNode with given value and newNode → next as NULL.
- Step 2: Check
whether list is Empty (head == NULL).
- Step 3: If
it is Empty then, set head = newNode.
- Step 4: If
it is Not Empty then, define a node pointer temp and
initialize with head.
- Step 5: Keep
moving the temp to its next node until it reaches
to the last node in the list (until temp → next is
equal to NULL).
- Step 6: Set temp → next = newNode.
Inserting
At Specific location in the list (After a Node)
We can use the following
steps to insert a new node after a node in the single linked list...
- Step 1: Create
a newNode with given value.
- Step 2: Check
whether list is Empty (head == NULL)
- Step 3: If
it is Empty then, set newNode → next = NULL
and head = newNode.
- Step 4: If
it is Not Empty then, define a node pointer temp and
initialize with head.
- Step 5: Keep
moving the temp to its next node until it reaches
to the node after which we want to insert the newNode (until temp1 → data is
equal to location, here location
is the node value after which we want to insert the newNode).
- Step 6: Every
time check whether temp is reached to last node or not.
If it is reached to last node then display 'Given node is not found in the list!!! Insertion not
possible!!!' and
terminate the function. Otherwise move the temp to
next node.
- Step 7: Finally,
Set 'newNode → next = temp → next'
and 'temp → next = newNode'
Deletion
In a single linked list,
the deletion operation can be performed in three ways. They are as follows...
1.
Deleting from Beginning of the list
2.
Deleting from End of the list
3.
Deleting a Specific Node
Deleting
from Beginning of the list
We can use the following
steps to delete a node from beginning of the single linked list...
- Step 1: Check
whether list is Empty (head == NULL)
- Step 2: If
it is Empty then, display 'List is Empty!!! Deletion is not possible' and terminate the function.
- Step 3: If
it is Not Empty then, define a Node pointer 'temp' and
initialize with head.
- Step 4: Check
whether list is having only one node (temp → next == NULL)
- Step 5: If
it is TRUE then set head = NULL and
delete temp (Setting Empty list
conditions)
- Step 6: If
it is FALSE then set head = temp → next,
and delete temp.
Deleting
from End of the list
We can use the following
steps to delete a node from end of the single linked list...
- Step 1: Check
whether list is Empty (head == NULL)
- Step 2: If
it is Empty then, display 'List is Empty!!! Deletion is not possible' and terminate the function.
- Step 3: If
it is Not Empty then, define two Node pointers 'temp1' and
'temp2' and initialize 'temp1' with head.
- Step 4: Check
whether list has only one Node (temp1
→ next == NULL)
- Step 5: If
it is TRUE. Then, set head = NULL and
delete temp1. And terminate
the function. (Setting Empty list condition)
- Step 6: If
it is FALSE. Then, set 'temp2 = temp1 ' and move temp1 to
its next node. Repeat the same until it reaches to the last node in the
list. (until temp1 → next == NULL)
- Step 7: Finally,
Set temp2 → next = NULL and
delete temp1.
Deleting
a Specific Node from the list
We can use the following
steps to delete a specific node from the single linked list...
- Step 1: Check
whether list is Empty (head == NULL)
- Step 2: If
it is Empty then, display 'List is Empty!!! Deletion is not possible' and terminate the function.
- Step 3: If
it is Not Empty then, define two Node pointers 'temp1' and
'temp2'
and initialize 'temp1'
with head.
- Step 4: Keep
moving the temp1 until it reaches to the exact
node to be deleted or to the last node. And every time set 'temp2 = temp1' before
moving the 'temp1'
to its next node.
- Step 5: If
it is reached to the last node then display 'Given node not found in the list! Deletion not
possible!!!'. And terminate the function.
- Step 6: If
it is reached to the exact node which we want to delete, then check
whether list is having only one node or not
- Step 7: If
list has only one node and that is the node to be deleted, then set head = NULL and
delete temp1 (free(temp1)).
- Step 8: If
list contains multiple nodes, then check whether temp1 is
the first node in the list (temp1
== head).
- Step 9: If temp1 is
the first node then move the head to the next node (head = head → next)
and delete temp1.
- Step 10: If temp1 is
not first node then check whether it is last node in the list (temp1 → next == NULL).
- Step 11: If temp1 is
last node then set temp2 → next = NULL and
delete temp1 (free(temp1)).
- Step 12: If temp1 is
not first node and not last node then set temp2 → next = temp1 → next and
delete temp1 (free(temp1)).
Displaying
a Single Linked List
We can use the following
steps to display the elements of a single linked list...
- Step 1: Check
whether list is Empty (head == NULL)
- Step 2: If
it is Empty then, display 'List is Empty!!!' and terminate the function.
- Step 3: If
it is Not Empty then, define a Node pointer 'temp' and
initialize with head.
- Step 4: Keep
displaying temp → data with
an arrow (--->)
until temp reaches to the last node
- Step 5: Finally
display temp → data with
arrow pointing to NULL (temp → data ---> NULL).
Concatenation of two
Linked Lists
Let
us assume that the two linked lists are referenced by head1 and head2 respectively.
1.
If the first linked list is empty then return head2.
2.
If the second linked list is empty then return head1.
3.
Store the address of the starting node of the first linked
list in a pointer variable, say p.
list in a pointer variable, say p.
4.
Move the p tothe last
node of the linked list through simple linked list traversal technique.
5.
Store the address of the first node of the second linked
list in the next field of the node pointed by p. Return head1.
list in the next field of the node pointed by p. Return head1.
Merge two sorted linked lists
Write a SortedMerge() function
that takes two lists, each of which is sorted in increasing order, and merges
the two together into one list which is in increasing order. SortedMerge()
should return the new list. The new list should be made by splicing
together the nodes of the first two
lists.
For
example if the first linked list a is 5->10->15 and the other linked list
b is 2->3->20, then SortedMerge() should return a pointer to the head
node of the merged list 2->3->5->10->15->20.
There are
many cases to deal with: either ‘a’ or ‘b’ may be empty, during processing
either ‘a’ or ‘b’ may run out first, and finally there’s the problem of
starting the result list empty, and building it up while going through ‘a’ and
‘b’.
Method 1 (Using Dummy Nodes)
The strategy here uses a temporary
dummy node as the start of the result list. The pointer Tail always points to
the last node in the result list, so appending new nodes is easy.
The dummy node gives tail something to point to initially when the result list is empty. This dummy node is efficient, since it is only temporary, and it is allocated in the stack. The loop proceeds, removing one node from either ‘a’ or ‘b’, and adding it to tail. When
we are done, the result is in dummy.next.
The dummy node gives tail something to point to initially when the result list is empty. This dummy node is efficient, since it is only temporary, and it is allocated in the stack. The loop proceeds, removing one node from either ‘a’ or ‘b’, and adding it to tail. When
we are done, the result is in dummy.next.
Method 2 (Using Local References)
This solution is structurally very
similar to the above, but it avoids using a dummy node. Instead, it maintains a
struct node** pointer, lastPtrRef, that always points to the last pointer of
the result list. This solves the same case that the dummy node did — dealing
with the result list when it is empty. If you are trying to build up a list at
its tail, either the dummy node or the struct node** “reference” strategy can
be used
Applications
of Linked List data structure
- Linked Lists can be used to implement
Stacks , Queues.
- Linked Lists can also be used to
implement Graphs. (Adjacency list representation of Graph).
- Implementing Hash Tables :
Each Bucket of the hash table can itself be a linked list. (Open chain
hashing).
- Undo functionality in Photoshop or Word .
Linked list of states.
- A polynomial can be represented in an
array or in a linked list by simply storing the coefficient and exponent
of each term.
- However, for any polynomial operation ,
such as addition or multiplication of polynomials , linked list
representation is more easier to deal with.
- Linked lists are useful for dynamic
memory allocation.
- The real life application where the
circular linked list is used is our Personal Computers, where multiple
applications are running.
- All the running applications are kept in
a circular linked list and the OS gives a fixed time slot to all for
running. The Operating System keeps on iterating over the linked list
until all the applications are completed.
