Data structure and algorithm list structures

Memory Representation of a doubly linked list
Memory Representation of a doubly linked list is shown in the following image.
Generally, doubly linked list consumes more space for every node and therefore, causes
more expansive basic operations such as insertion and deletion. However, we can easily
manipulate the elements of the list since the list maintains pointers in both the
directions (forward and backward).
In the following image, the first element of the list that is i.e. 13 stored at address 1.
The head pointer points to the starting address 1. Since this is the first element being
added to the list therefore the prev of the list contains null. The next node of the list
resides at address 4 therefore the first node contains 4 in its next pointer.
We can traverse the list in this way until we find any node containing null or -1 in its
next part.

Operations on doubly linked list
Node Creation
struct node
{
struct node *prev;
int data;
struct node *next;
};
struct node *head;
Node Creation
oid insertion_beginning()
{
struct node *ptr;
int item;
ptr = (struct node *)malloc(sizeof(struct node));
if(ptr == NULL)
{
printf("nOVERFLOW");
}
else
{
printf("nEnter Item value");
scanf("%d",&item);
if(head==NULL)
{
ptr->next = NULL;
ptr->prev=NULL;
ptr->data=item;
head=ptr;
}
else
{
ptr->data=item;
ptr->prev=NULL;
ptr->next = head;
head->prev=ptr;
head=ptr;
}
printf("nNode insertedn");
}
}
void deletion_beginning()
{
struct node *ptr;
if(head == NULL)
{
printf("n UNDERFLOW");
}
else if(head->next == NULL)
{
head = NULL;
free(head);
printf("nnode deletedn");
}
else
{
ptr = head;
head = head -> next;
head -> prev = NULL;
free(ptr);
printf("nnode deletedn");
}
}

Operations on doubly linked list
void search()
{
struct node *ptr;
int item,i=0,flag;
ptr = head;
if(ptr == NULL)
{
printf("nEmpty Listn");
}
else
{
printf("
nEnter item which you want to search?
n");
scanf("%d",&item);
while (ptr!=NULL)
{
if(ptr->data == item)
{
printf("
nitem found at location %d ",i+1);
flag=0;
break;
}
else
{
flag=1;
}
i++;
ptr = ptr -> next;
}
if(flag==1)
{
printf("nItem not foundn");
}
}
}

Circular Linked List
• Circular linked list is a linked list
where all nodes are connected to
form a circle.
• There is no NULL at the end.
• A circular linked list can be a singly
circular linked list or doubly
circular linked list.

Advantages of Circular Linked Lists
• Any node can be a starting point.
We can traverse the whole list by
starting from any point. We just
need to stop when the first visited
node is visited again.
• Useful for implementation of
queue.
• For example, when multiple
applications are running on a PC

OPERATIONS ON CIRCULARLY
LINKED LIST
• Insertion
• Deletion
• Display
Circular linked list – Creation
temp=head;
temp->next = new;
new -> next = head;

Insertion in a Circular Linked List
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
Steps to insert a new node at beginning of the
circular 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 head = newNode and newNode→next = head .
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 (until 'temp → next == head').
Step 6 - Set 'newNode → next =head',
'head = newNode' and 'temp → next = head'.

Inserting At the End of the list
• Steps to insert a new node at end of the circular linked
list...
Step 2 - Check whether list is Empty (head == NULL).
Step 3 - If it is Empty then,
set head = newNode and newNode → next = head.
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 == head).
Step 6 - Set temp → next = newNode and newNode →
next = head.

Inserting At Specific location in the list (After
a Node)
Step 3 - If it is Empty then, set head = newNode and newNode → next = head.
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 the 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 - If temp is reached to the exact node after which we want to insert the newNode then check
whether it is last node (temp → next == head).
Step 8 - If temp is last node then set temp → next = newNode and newNode → next = head.
Step 8 - If temp is not last node then set newNode → next = temp → next and temp →
next = newNode.

CLL – Insertion (ROUTINE)
Insertion at first
new->next = head
head =new;
temp->next= head;
Insertion at middle
n1->next = new;
new->next = n2;
n2->next = head;
Insertion at last
n2->next=new;
new->next = head;

CLL – Deletion Operation
• In a circular linked list, the deletion operation
can be performed in three ways those 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
• The following steps to delete a node from beginning of the circular
linked list...
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 both 'temp1' and 'temp2' with head.
Step 4 - Check whether list is having only one node (temp1 →
next == head)
Step 5 - If it is TRUE then set head = NULL and
delete temp1 (Setting Empty list conditions)
Step 6 - If it is FALSE move the temp1 until it reaches to the last node.
(until temp1 → next == head )
Step 7 - Then set head = temp2 → next, temp1 → next = head and
delete temp2.

DELETING FROM END OF THE LIST
• The following steps to delete a node from end of the circular
linked list...
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 == head)
Step 5 - If it is TRUE. Then, set head = NULL and delete temp1. And
terminate from 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 temp1 reaches to the last node in the
list. (until temp1 → next == head)
Step 7 - Set temp2 → next = head and delete temp1.

DELETING A SPECIFIC NODE FROM THE LIST
• The following steps to delete a specific node from the circular linked list...
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 (temp1 → next == head)
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 set temp2 = head and keep moving temp2 to its next node
until temp2 reaches to the last node. Then set head = head → next, temp2 → next = head and
delete temp1.
Step 10 - If temp1 is not first node then check whether it is last node in the list (temp1 → next == head).
Step 11- If temp1 is last node then set temp2 → next = head 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)).

CLL - Deletion Operation
//delete first item
struct node * deleteFirst() {
//save reference to first link
struct node *tempLink = head;
if(head->next == head){
head = NULL;
return tempLink;
}
//mark next to first link as first
head = head->next;
//return the deleted link
return tempLink;
}

Deleting first node from Singly Circular Linked List
• Given a Circular Linked List. The task is to write programs to delete
nodes
from this list present at:
• First position.
• Last Position.
• At any given position i.

Deleting the last node of the Circular Linked List

Deleting nodes at given index in the
Circular linked list

Array versus Linked Lists
• Linked lists are more complex to code and
manage than arrays, but they have some distinct
advantages.
• Dynamic: a linked list can easily grow and shrink in
size.
• We don’t need to know how many nodes will be in the
list. They are created in memory as needed.
• In contrast, the size of a C++ array is fixed at
compilation time.
• Easy and fast insertions and deletions
• To insert or delete an element in an array, we need to
copy to temporary variables to make room for new
elements or close the gap caused by deleted elements.
• With a linked list, no need to move other nodes. Only
need to reset some pointers.

Data structure and algorithm list structures

More Related Content

Similar to Data structure and algorithm list structures

Recently uploaded

Data structure and algorithm list structures