Delete all odd or even positioned nodes from Circular Linked List
Last Updated :
08 Sep, 2022
Delete all odd or even position nodes from circular linked list
Given a Singly Circular Linked List, starting from the first node delete all odd position nodes in it.
Note: Linked list is considered to have 1-based indexing. That is, first element in the linked list is at position 1.
Examples:
Input : List = 99->11->22->33
Output : 11->33
Input : List = 90->10->20->30
Output : 10->30
The idea is to start traversing the circular linked list using a count variable to keep track of the position of current node. If the current node is at odd position then delete that node using the approach discussed in Delete node from Circular Linked List.
Implementation: Function to delete all odd positioned nodes.
C++
// Function to delete that all
// node whose index position is odd
void DeleteAllOddNode(struct Node** head)
{
int len = Length(*head);
int count = 0;
struct Node *previous = *head, *next = *head;
// check list have any node
// if not then return
if (*head == NULL) {
printf("\nDelete Last List is empty\n");
return;
}
// if list have single node means
// odd position then delete it
if (len == 1) {
DeleteFirst(head);
return;
}
// traverse first to last if
// list have more than one node
while (len > 0) {
// delete first position node
// which is odd position
if (count == 0) {
// Function to delete first node
DeleteFirst(head);
}
// check position is odd or not
// if yes then delete node
if (count % 2 == 0 && count != 0) {
deleteNode(*head, previous);
}
previous = previous->next;
next = previous->next;
len--;
count++;
}
return;
}
// Function to delete that all
// node whose index position is odd
static void DeleteAllOddNode(Node head)
{
int len = Length(head);
int count = 0;
Node previous = head, next = head;
// Check list have any node
// if not then return
if (head == null)
{
System.out.printf("\nDelete Last List is empty\n");
return;
}
// If list have single node means
// odd position then delete it
if (len == 1)
{
DeleteFirst(head);
return;
}
// Traverse first to last if
// list have more than one node
while (len > 0)
{
// Delete first position node
// which is odd position
if (count == 0)
{
// Function to delete first node
DeleteFirst(head);
}
// Check position is odd or not
// if yes then delete node
if (count % 2 == 0 && count != 0)
{
deleteNode(head, previous);
}
previous = previous.next;
next = previous.next;
len--;
count++;
}
return;
}
// This code is contributed by aashish1995
// Function to delete that all
// node whose index position is odd
static Node DeleteAllOddNode(Node head)
{
int len = Length(head);
int count = 0;
Node previous = head, next = head;
// check list have any node
// if not then return
if (head == null)
{
Console.Write("\nDelete Last List is empty\n");
return null;
}
// if list have single node means
// odd position then delete it
if (len == 1)
{
head = DeleteFirst(head);
return head;
}
// traverse first to last if
// list have more than one node
while (len > 0)
{
// delete first position node
// which is odd position
if (count == 0)
{
// Function to delete first node
head = DeleteFirst(head);
}
// check position is odd or not
// if yes then delete node
// Note: Considered 1 based indexing
if (count % 2 == 0 && count != 0)
{
head = deleteNode(head, previous);
}
previous = previous.next;
next = previous.next;
len--;
count++;
}
return head;
}
// This code is contributed by shivanisinghss2110
<script>
// Function to delete that all
// node whose index position is odd
function DeleteAllOddNode( head)
{
let len = Length(head);
let count = 0;
var previous = head, next = head;
// Check list have any node
// if not then return
if (head == null)
{
document.write("</br>" +
"Delete Last List is empty" +
"</br>");
return null;
}
// If list have single node means
// odd position then delete it
if (len == 1)
{
head = DeleteFirst(head);
return head;
}
// Traverse first to last if
// list have more than one node
while (len > 0)
{
// Delete first position node
// which is odd position
if (count == 0)
{
// Function to delete first node
head = DeleteFirst(head);
}
// Check position is odd or not
// if yes then delete node
// Note: Considered 1 based indexing
if (count % 2 == 0 && count != 0)
{
head = deleteNode(head, previous);
}
previous = previous.next;
next = previous.next;
len--;
count++;
}
return head;
}
// This code is contributed by itsok
</script>
# Function to delete odd position nodes
def DeleteAllOddNode(head):
len = Length(head)
count = 0
previous = head
next = head
# check list have any node
# if not then return
if (head == None):
print("\nDelete Last List is empty")
return
# if list have single node means
# odd position then delete it
if (len == 1):
head=DeleteFirst(head)
return head
# traverse first to last if
# list have more than one node
while (len > 0):
# delete first position node
# which is odd position
if (count == 0):
# Function to delete first node
head=DeleteFirst(head)
# check position is odd or not
# if yes then delete node
# Note: Considered 1 based indexing
if (count % 2 == 0 and count != 0):
deleteNode(head, previous)
previous = previous.next
next = previous.next
len-=1
count+=1
return head
Delete all even position nodes from circular linked list
Given a Singly Circular Linked List. The task is to delete all nodes at even positions in this list. That is all starting from the second node delete all alternate nodes of the list.
Examples:
Input : List = 99->11->22->33
Output : 99->22
Input : List = 90->10->20->30
Output : 90->20
Note: Linked list is considered to have 1-based indexing. That is, first element in the linked list is at position 1.
The idea is to start traversing the circular linked list using a count variable to keep track of the position of the current node. If the current node is at even position then delete that node using the approach discussed in Delete node from Circular Linked List.
Implementation: Function to delete even positioned nodes.
C++
// Function to delete all even position nodes
void DeleteAllEvenNode(struct Node** head)
{
// Take size of list
int len = Length(*head);
int count = 1;
struct Node *previous = *head, *next = *head;
// Check list is empty
// if empty simply return
if (*head == NULL) {
printf("\nList is empty\n");
return;
}
// if list have single node
// then return
if (len < 2) {
return;
}
// make first node is previous
previous = *head;
// make second node is current
next = previous->next;
while (len > 0) {
// check node number is even
// if node is even then
// delete that node
if (count % 2 == 0) {
previous->next = next->next;
free(next);
previous = next->next;
next = previous->next;
}
len--;
count++;
}
return;
}
// Function to delete all even position nodes
static Node DeleteAllEvenNode( Node head)
{
// Take size of list
int len = Length(head);
int count = 1;
Node previous = head, next = head;
// Check list is empty
// if empty simply return
if (head == null)
{
System.out.printf("\nList is empty\n");
return null;
}
// if list have single node
// then return
if (len < 2)
{
return null;
}
// make first node is previous
previous = head;
// make second node is current
next = previous.next;
while (len > 0)
{
// check node number is even
// if node is even then
// delete that node
if (count % 2 == 0)
{
previous.next = next.next;
previous = next.next;
next = previous.next;
}
len--;
count++;
}
return head;
}
// This code is contributed by rutvik_56
// Function to delete all even position nodes
static Node DeleteAllEvenNode(Node head)
{
// Take size of list
int len = Length(head);
int count = 1;
Node previous = head, next = head;
// Check list is empty
// if empty simply return
if (head == null)
{
Console.Write("\nList is empty\n");
return null;
}
// If list have single node
// then return
if (len < 2)
{
return null;
}
// Make first node is previous
previous = head;
// Make second node is current
next = previous.next;
while (len > 0)
{
// Check node number is even
// if node is even then
// delete that node
if (count % 2 == 0)
{
previous.next = next.next;
previous = next.next;
next = previous.next;
}
len--;
count++;
}
return head;
}
// This code is contributed by pratham76
<script>
// Function to delete all even position nodes
function DeleteAllEvenNode( head)
{
// Take size of list
var len = Length(head);
var count = 1;
var previous = head, next = head;
// Check list is empty
// if empty simply return
if (head == null)
{
document.write("\nList is empty\n");
return null;
}
// if list have single node
// then return
if (len < 2)
{
return null;
}
// make first node is previous
previous = head;
// make second node is current
next = previous.next;
while (len > 0)
{
// check node number is even
// if node is even then
// delete that node
if (count % 2 == 0)
{
previous.next = next.next;
previous = next.next;
next = previous.next;
}
len--;
count++;
}
return head;
}
// This code contributed by umadevi9616
</script>
# Function to delete all even position nodes
def DeleteAllEvenNode(head):
# Take size of list
len = Length(head)
count = 1
previous = head
next = head
# Check list is empty
# if empty simply return
if (head == None):
print("\nList is empty")
return
# if list have single node
# then return
if (len < 2):
return
# make first node is previous
previous = head
# make second node is current
next = previous.next
while (len > 0):
# check node number is even
# if node is even then
# delete that node
if (count % 2 == 0):
previous.next = next.next
# del(next)
previous = next.next
next = previous.next
len-=1
count+=1
return head
Implementation: Program to delete Even or Odd positioned nodes.
C++
// C++ program to delete all even and odd position
// nodes from Singly Circular Linked list
#include <bits/stdc++.h>
// structure for a node
struct Node {
int data;
struct Node* next;
};
// Function return number of nodes present in list
int Length(struct Node* head)
{
struct Node* current = head;
int count = 0;
// if list is empty simply return length zero
if (head == NULL) {
return 0;
}
// traverse first to last node
else {
do {
current = current->next;
count++;
} while (current != head);
}
return count;
}
// Function print data of list
void Display(struct Node* head)
{
struct Node* current = head;
// if list is empty simply show message
if (head == NULL) {
printf("\nDisplay List is empty\n");
return;
}
// traverse first to last node
else {
do {
printf("%d ", current->data);
current = current->next;
} while (current != head);
}
}
/* Function to insert a node at the end of
a Circular linked list */
void Insert(struct Node** head, int data)
{
struct Node* current = *head;
// Create a new node
struct Node* newNode = new Node;
// check node is created or not
if (!newNode) {
printf("\nMemory Error\n");
return;
}
// insert data into newly created node
newNode->data = data;
// check list is empty
// if not have any node then
// make first node it
if (*head == NULL) {
newNode->next = newNode;
*head = newNode;
return;
} // if list have already some node
else {
// move first node to last node
while (current->next != *head) {
current = current->next;
}
// put first or head node address in new node link
newNode->next = *head;
// put new node address into last node link(next)
current->next = newNode;
}
}
// Utility function to delete a Node
void deleteNode(struct Node* head_ref, struct Node* del)
{
struct Node* temp = head_ref;
// If node to be deleted is head node
if (head_ref == del) {
head_ref = del->next;
}
// traverse list till not found
// delete node
while (temp->next != del) {
temp = temp->next;
}
// copy address of node
temp->next = del->next;
// Finally, free the memory
// occupied by del
free(del);
return;
}
// Function to delete First node of
// Circular Linked List
void DeleteFirst(struct Node** head)
{
struct Node *previous = *head, *next = *head;
// check list have any node
// if not then return
if (*head == NULL) {
printf("\nList is empty\n");
return;
}
// check list have single node
// if yes then delete it and return
if (previous->next == previous) {
*head = NULL;
return;
}
// traverse second to first
while (previous->next != *head) {
previous = previous->next;
next = previous->next;
}
// now previous is last node and
// next is first node of list
// first node(next) link address
// put in last node(previous) link
previous->next = next->next;
// make second node as head node
*head = previous->next;
free(next);
return;
}
// Function to delete odd position nodes
void DeleteAllOddNode(struct Node** head)
{
int len = Length(*head);
int count = 0;
struct Node *previous = *head, *next = *head;
// check list have any node
// if not then return
if (*head == NULL) {
printf("\nDelete Last List is empty\n");
return;
}
// if list have single node means
// odd position then delete it
if (len == 1) {
DeleteFirst(head);
return;
}
// traverse first to last if
// list have more than one node
while (len > 0) {
// delete first position node
// which is odd position
if (count == 0) {
// Function to delete first node
DeleteFirst(head);
}
// check position is odd or not
// if yes then delete node
// Note: Considered 1 based indexing
if (count % 2 == 0 && count != 0) {
deleteNode(*head, previous);
}
previous = previous->next;
next = previous->next;
len--;
count++;
}
return;
}
// Function to delete all even position nodes
void DeleteAllEvenNode(struct Node** head)
{
// Take size of list
int len = Length(*head);
int count = 1;
struct Node *previous = *head, *next = *head;
// Check list is empty
// if empty simply return
if (*head == NULL) {
printf("\nList is empty\n");
return;
}
// if list have single node
// then return
if (len < 2) {
return;
}
// make first node is previous
previous = *head;
// make second node is current
next = previous->next;
while (len > 0) {
// check node number is even
// if node is even then
// delete that node
if (count % 2 == 0) {
previous->next = next->next;
free(next);
previous = next->next;
next = previous->next;
}
len--;
count++;
}
return;
}
// Driver Code
int main()
{
struct Node* head = NULL;
Insert(&head, 99);
Insert(&head, 11);
Insert(&head, 22);
Insert(&head, 33);
Insert(&head, 44);
Insert(&head, 55);
Insert(&head, 66);
// Deleting Odd positioned nodes
printf("Initial List: ");
Display(head);
printf("\nAfter deleting Odd position nodes: ");
DeleteAllOddNode(&head);
Display(head);
// Deleting Even positioned nodes
printf("\n\nInitial List: ");
Display(head);
printf("\nAfter deleting even position nodes: ");
DeleteAllEvenNode(&head);
Display(head);
return 0;
}
// Java program to delete all even and odd position
// nodes from Singly Circular Linked list
class GFG
{
// structure for a node
static class Node
{
int data;
Node next;
};
// Function return number of nodes present in list
static int Length(Node head)
{
Node current = head;
int count = 0;
// if list is empty simply return length zero
if (head == null)
{
return 0;
}
// traverse first to last node
else
{
do
{
current = current.next;
count++;
} while (current != head);
}
return count;
}
// Function print data of list
static void Display( Node head)
{
Node current = head;
// if list is empty simply show message
if (head == null)
{
System.out.printf("\nDisplay List is empty\n");
return;
}
// traverse first to last node
else
{
do
{
System.out.printf("%d ", current.data);
current = current.next;
} while (current != head);
}
}
/* Function to insert a node at the end of
a Circular linked list */
static Node Insert(Node head, int data)
{
Node current = head;
// Create a new node
Node newNode = new Node();
// check node is created or not
if (newNode == null)
{
System.out.printf("\nMemory Error\n");
return null;
}
// insert data into newly created node
newNode.data = data;
// check list is empty
// if not have any node then
// make first node it
if (head == null)
{
newNode.next = newNode;
head = newNode;
return head;
}
// if list have already some node
else
{
// move first node to last node
while (current.next != head)
{
current = current.next;
}
// put first or head node address in new node link
newNode.next = head;
// put new node address into last node link(next)
current.next = newNode;
}
return head;
}
// Utility function to delete a Node
static Node deleteNode(Node head_ref, Node del)
{
Node temp = head_ref;
// If node to be deleted is head node
if (head_ref == del)
{
head_ref = del.next;
}
// traverse list till not found
// delete node
while (temp.next != del)
{
temp = temp.next;
}
// copy address of node
temp.next = del.next;
return head_ref;
}
// Function to delete First node of
// Circular Linked List
static Node DeleteFirst(Node head)
{
Node previous = head, next = head;
// check list have any node
// if not then return
if (head == null)
{
System.out.printf("\nList is empty\n");
return head;
}
// check list have single node
// if yes then delete it and return
if (previous.next == previous)
{
head = null;
return head;
}
// traverse second to first
while (previous.next != head)
{
previous = previous.next;
next = previous.next;
}
// now previous is last node and
// next is first node of list
// first node(next) link address
// put in last node(previous) link
previous.next = next.next;
// make second node as head node
head = previous.next;
return head;
}
// Function to delete odd position nodes
static Node DeleteAllOddNode(Node head)
{
int len = Length(head);
int count = 0;
Node previous = head, next = head;
// check list have any node
// if not then return
if (head == null)
{
System.out.printf("\nDelete Last List is empty\n");
return null;
}
// if list have single node means
// odd position then delete it
if (len == 1)
{
head = DeleteFirst(head);
return head;
}
// traverse first to last if
// list have more than one node
while (len > 0)
{
// delete first position node
// which is odd position
if (count == 0)
{
// Function to delete first node
head = DeleteFirst(head);
}
// check position is odd or not
// if yes then delete node
// Note: Considered 1 based indexing
if (count % 2 == 0 && count != 0)
{
head = deleteNode(head, previous);
}
previous = previous.next;
next = previous.next;
len--;
count++;
}
return head;
}
// Function to delete all even position nodes
static Node DeleteAllEvenNode( Node head)
{
// Take size of list
int len = Length(head);
int count = 1;
Node previous = head, next = head;
// Check list is empty
// if empty simply return
if (head == null)
{
System.out.printf("\nList is empty\n");
return null;
}
// if list have single node
// then return
if (len < 2)
{
return null;
}
// make first node is previous
previous = head;
// make second node is current
next = previous.next;
while (len > 0)
{
// check node number is even
// if node is even then
// delete that node
if (count % 2 == 0)
{
previous.next = next.next;
previous = next.next;
next = previous.next;
}
len--;
count++;
}
return head;
}
// Driver Code
public static void main(String args[])
{
Node head = null;
head = Insert(head, 99);
head = Insert(head, 11);
head = Insert(head, 22);
head = Insert(head, 33);
head = Insert(head, 44);
head = Insert(head, 55);
head = Insert(head, 66);
// Deleting Odd positioned nodes
System.out.printf("Initial List: ");
Display(head);
System.out.printf("\nAfter deleting Odd position nodes: ");
head = DeleteAllOddNode(head);
Display(head);
// Deleting Even positioned nodes
System.out.printf("\n\nInitial List: ");
Display(head);
System.out.printf("\nAfter deleting even position nodes: ");
head = DeleteAllEvenNode(head);
Display(head);
}
}
// This code is contributed by Arnab Kundu
// C# program to delete all even and
// odd position nodes from
// Singly Circular Linked list
using System;
class GFG
{
// structure for a node
class Node
{
public int data;
public Node next;
};
// Function return number of nodes
// present in list
static int Length(Node head)
{
Node current = head;
int count = 0;
// if list is empty simply return
// length zero
if (head == null)
{
return 0;
}
// traverse first to last node
else
{
do
{
current = current.next;
count++;
} while (current != head);
}
return count;
}
// Function print data of list
static void Display( Node head)
{
Node current = head;
// if list is empty simply show message
if (head == null)
{
Console.Write("\nDisplay List is empty\n");
return;
}
// traverse first to last node
else
{
do
{
Console.Write("{0} ", current.data);
current = current.next;
} while (current != head);
}
}
/* Function to insert a node at the end of
a Circular linked list */
static Node Insert(Node head, int data)
{
Node current = head;
// Create a new node
Node newNode = new Node();
// check node is created or not
if (newNode == null)
{
Console.Write("\nMemory Error\n");
return null;
}
// insert data into newly created node
newNode.data = data;
// check list is empty
// if not have any node then
// make first node it
if (head == null)
{
newNode.next = newNode;
head = newNode;
return head;
}
// if list have already some node
else
{
// move first node to last node
while (current.next != head)
{
current = current.next;
}
// put first or head node address
// in new node link
newNode.next = head;
// put new node address into
// last node link(next)
current.next = newNode;
}
return head;
}
// Utility function to delete a Node
static Node deleteNode(Node head_ref,
Node del)
{
Node temp = head_ref;
// If node to be deleted is head node
if (head_ref == del)
{
head_ref = del.next;
}
// traverse list till not found
// delete node
while (temp.next != del)
{
temp = temp.next;
}
// copy address of node
temp.next = del.next;
return head_ref;
}
// Function to delete First node of
// Circular Linked List
static Node DeleteFirst(Node head)
{
Node previous = head, next = head;
// check list have any node
// if not then return
if (head == null)
{
Console.Write("\nList is empty\n");
return head;
}
// check list have single node
// if yes then delete it and return
if (previous.next == previous)
{
head = null;
return head;
}
// traverse second to first
while (previous.next != head)
{
previous = previous.next;
next = previous.next;
}
// now previous is last node and
// next is first node of list
// first node(next) link address
// put in last node(previous) link
previous.next = next.next;
// make second node as head node
head = previous.next;
return head;
}
// Function to delete odd position nodes
static Node DeleteAllOddNode(Node head)
{
int len = Length(head);
int count = 0;
Node previous = head, next = head;
// check list have any node
// if not then return
if (head == null)
{
Console.Write("\nDelete Last List is empty\n");
return null;
}
// if list have single node means
// odd position then delete it
if (len == 1)
{
head = DeleteFirst(head);
return head;
}
// traverse first to last if
// list have more than one node
while (len > 0)
{
// delete first position node
// which is odd position
if (count == 0)
{
// Function to delete first node
head = DeleteFirst(head);
}
// check position is odd or not
// if yes then delete node
// Note: Considered 1 based indexing
if (count % 2 == 0 && count != 0)
{
head = deleteNode(head, previous);
}
previous = previous.next;
next = previous.next;
len--;
count++;
}
return head;
}
// Function to delete all even position nodes
static Node DeleteAllEvenNode( Node head)
{
// Take size of list
int len = Length(head);
int count = 1;
Node previous = head, next = head;
// Check list is empty
// if empty simply return
if (head == null)
{
Console.Write("\nList is empty\n");
return null;
}
// if list have single node
// then return
if (len < 2)
{
return null;
}
// make first node is previous
previous = head;
// make second node is current
next = previous.next;
while (len > 0)
{
// check node number is even
// if node is even then
// delete that node
if (count % 2 == 0)
{
previous.next = next.next;
previous = next.next;
next = previous.next;
}
len--;
count++;
}
return head;
}
// Driver Code
public static void Main(String []args)
{
Node head = null;
head = Insert(head, 99);
head = Insert(head, 11);
head = Insert(head, 22);
head = Insert(head, 33);
head = Insert(head, 44);
head = Insert(head, 55);
head = Insert(head, 66);
// Deleting Odd positioned nodes
Console.Write("Initial List: ");
Display(head);
Console.Write("\nAfter deleting Odd position nodes: ");
head = DeleteAllOddNode(head);
Display(head);
// Deleting Even positioned nodes
Console.Write("\n\nInitial List: ");
Display(head);
Console.Write("\nAfter deleting even position nodes: ");
head = DeleteAllEvenNode(head);
Display(head);
}
}
// This code is contributed by Rajput-Ji
<script>
// Javascript program to delete all even and odd position
// nodes from Singly Circular Linked list
// Link list node
class Node {
constructor() {
this.data = 0;
this.next = null;
}
}
// Function return number of nodes present in list
function Length( head)
{
var current = head;
let count = 0;
// if list is empty simply return length zero
if (head == null)
{
return 0;
}
// traverse first to last node
else
{
do
{
current = current.next;
count++;
} while (current != head);
}
return count;
}
// Function print data of list
function Display( head)
{
var current = head;
// if list is empty simply show message
if (head == null)
{
document.write("</br>"+"Display List is empty"+"</br>");
return;
}
// traverse first to last node
else
{
do
{
document.write( current.data + " ");
current = current.next;
} while (current != head);
}
}
/* Function to insert a node at the end of
a Circular linked list */
function Insert( head, data)
{
var current = head;
// Create a new node
var newNode = new Node();
// check node is created or not
if (newNode == null)
{
document.write("</br>"+"Memory Error"+"</br>");
return null;
}
// insert data into newly created node
newNode.data = data;
// check list is empty
// if not have any node then
// make first node it
if (head == null)
{
newNode.next = newNode;
head = newNode;
return head;
}
// if list have already some node
else
{
// move first node to last node
while (current.next != head)
{
current = current.next;
}
// put first or head node address in new node link
newNode.next = head;
// put new node address into last node link(next)
current.next = newNode;
}
return head;
}
// Utility function to delete a Node
function deleteNode( head_ref, del)
{
var temp = head_ref;
// If node to be deleted is head node
if (head_ref == del)
{
head_ref = del.next;
}
// traverse list till not found
// delete node
while (temp.next != del)
{
temp = temp.next;
}
// copy address of node
temp.next = del.next;
return head_ref;
}
// Function to delete First node of
// Circular Linked List
function DeleteFirst( head)
{
var previous = head, next = head;
// check list have any node
// if not then return
if (head == null)
{
document.write("</br>"+"List is empty"+"</br>");
return head;
}
// check list have single node
// if yes then delete it and return
if (previous.next == previous)
{
head = null;
return head;
}
// traverse second to first
while (previous.next != head)
{
previous = previous.next;
next = previous.next;
}
// now previous is last node and
// next is first node of list
// first node(next) link address
// put in last node(previous) link
previous.next = next.next;
// make second node as head node
head = previous.next;
return head;
}
// Function to delete odd position nodes
function DeleteAllOddNode( head)
{
let len = Length(head);
let count = 0;
var previous = head, next = head;
// check list have any node
// if not then return
if (head == null)
{
document.write("</br>"+"Delete Last List is empty"+"</br>");
return null;
}
// if list have single node means
// odd position then delete it
if (len == 1)
{
head = DeleteFirst(head);
return head;
}
// traverse first to last if
// list have more than one node
while (len > 0)
{
// delete first position node
// which is odd position
if (count == 0)
{
// Function to delete first node
head = DeleteFirst(head);
}
// check position is odd or not
// if yes then delete node
// Note: Considered 1 based indexing
if (count % 2 == 0 && count != 0)
{
head = deleteNode(head, previous);
}
previous = previous.next;
next = previous.next;
len--;
count++;
}
return head;
}
// Function to delete all even position nodes
function DeleteAllEvenNode( head)
{
// Take size of list
let len = Length(head);
let count = 1;
var previous = head, next = head;
// Check list is empty
// if empty simply return
if (head == null)
{
document.write("</br>"+"List is empty"+"</br>");
return null;
}
// if list have single node
// then return
if (len < 2)
{
return null;
}
// make first node is previous
previous = head;
// make second node is current
next = previous.next;
while (len > 0)
{
// check node number is even
// if node is even then
// delete that node
if (count % 2 == 0)
{
previous.next = next.next;
previous = next.next;
next = previous.next;
}
len--;
count++;
}
return head;
}
// Driver Code
var head = null;
head = Insert(head, 99);
head = Insert(head, 11);
head = Insert(head, 22);
head = Insert(head, 33);
head = Insert(head, 44);
head = Insert(head, 55);
head = Insert(head, 66);
// Deleting Odd positioned nodes
document.write("Initial List: ");
Display(head);
document.write("</br>"+"After deleting Odd position nodes: ");
head = DeleteAllOddNode(head);
Display(head);
// Deleting Even positioned nodes
document.write("</br>"+"</br>"+"Initial List: ");
Display(head);
document.write("</br>"+"After deleting even position nodes: ");
head = DeleteAllEvenNode(head);
Display(head);
// This code is contributed by jana_sayanta.
</script>
# Python3 program to delete all even and odd position
# nodes from Singly Circular Linked list
# class for a node
class Node:
def __init__(self,data):
self.data=data
self.next=None
# Function return number of nodes present in list
def Length(head):
current = head
count = 0
# if list is empty simply return length zero
if head == None:
return 0
# traverse first to last node
else:
while(True):
current = current.next
count+=1
if current == head:
break
return count
# Function print data of list
def Display(head):
current = head
# if list is empty simply show message
if head == None:
print("\nDisplay List is empty")
return
# traverse first to last node
else:
while True:
print(current.data,end=' ')
current = current.next
if current == head:
break
# Function to insert a node at the end of
# a Circular linked list
def Insert(head, data):
current = head
# Create a new node
newNode = Node(data)
# check list is empty
# if not have any node then
# make first node it
if head == None:
newNode.next = newNode
head = newNode
return
# if list have already some node
else:
# move first node to last node
while (current.next != head):
current = current.next
# put first or head node address in new node link
newNode.next = head
# put new node address into last node link(next)
current.next = newNode
# Utility function to delete a Node
def deleteNode(head_ref, del_ref):
temp = head_ref
# If node to be deleted is head node
if (head_ref == del_ref):
head_ref = del_ref.next
# traverse list till not found
# delete node
while (temp.next != del_ref):
temp = temp.next
# copy address of node
temp.next = del_ref.next
# Finally, free the memory
# occupied by del
del(del_ref)
return
# Function to delete First node of
# Circular Linked List
def DeleteFirst(head):
previous = head; next = head
# check list have any node
# if not then return
if (head == None):
print("\nList is empty")
return
# check list have single node
# if yes then delete it and return
if (previous.next == previous):
return None
# traverse second to first
while (previous.next != head):
previous = previous.next
next = previous.next
# now previous is last node and
# next is first node of list
# first node(next) link address
# put in last node(previous) link
previous.next = next.next
# make second node as head node
head = previous.next
return head
# Function to delete odd position nodes
def DeleteAllOddNode(head):
len = Length(head)
count = 0
previous = head
next = head
# check list have any node
# if not then return
if (head == None):
print("\nDelete Last List is empty")
return
# if list have single node means
# odd position then delete it
if (len == 1):
head=DeleteFirst(head)
return head
# traverse first to last if
# list have more than one node
while (len > 0):
# delete first position node
# which is odd position
if (count == 0):
# Function to delete first node
head=DeleteFirst(head)
# check position is odd or not
# if yes then delete node
# Note: Considered 1 based indexing
if (count % 2 == 0 and count != 0):
deleteNode(head, previous)
previous = previous.next
next = previous.next
len-=1
count+=1
return head
# Function to delete all even position nodes
def DeleteAllEvenNode(head):
# Take size of list
len = Length(head)
count = 1
previous = head
next = head
# Check list is empty
# if empty simply return
if (head == None):
print("\nList is empty")
return
# if list have single node
# then return
if (len < 2):
return
# make first node is previous
previous = head
# make second node is current
next = previous.next
while (len > 0):
# check node number is even
# if node is even then
# delete that node
if (count % 2 == 0):
previous.next = next.next
# del(next)
previous = next.next
next = previous.next
len-=1
count+=1
return
# Driver Code
if __name__ == '__main__':
head = Node(99)
head.next=head
Insert(head, 11)
Insert(head, 22)
Insert(head, 33)
Insert(head, 44)
Insert(head, 55)
Insert(head, 66)
# Deleting Odd positioned nodes
print("Initial List: ",end='')
Display(head)
print("\nAfter deleting Odd position nodes: ",end='')
head=DeleteAllOddNode(head)
Display(head)
# Deleting Even positioned nodes
print("\n\nInitial List: ",end='')
Display(head)
print("\nAfter deleting even position nodes: ",end='')
DeleteAllEvenNode(head)
Display(head)
print()
# This code is contributed by Amartya Ghosh
OutputInitial List: 99 11 22 33 44 55 66
After deleting Odd position nodes: 11 33 55
Initial List: 11 33 55
After deleting even position nodes: 11 55
Complexity Analysis:
- Time Complexity: O(N)
- Auxiliary Space: O(1)
Similar Reads
Delete all the even nodes of a Circular Linked List
Given a circular singly linked list containing N nodes, the task is to delete all the even nodes from the list. Examples: Input : 57->11->2->56->12->61 Output : List after deletion : 57 -> 11 -> 61 Input : 9->11->32->6->13->20 Output : List after deletion : 9 -
10 min read
Delete all Prime Nodes from a Circular Singly Linked List
Given a circular singly linked list containing N nodes. The task is to delete all nodes from the list which are prime. Examples: Input : 9->11->32->6->13->20 Output : 9 32 6 20 Input : 6->11->16->21->17->10 Output : 6 16 21 10 Approach: The idea is to traverse the nodes
13 min read
Delete all odd nodes of a Circular Linked List
Prerequisite: Delete all the even nodes of a Circular Linked ListGiven a circular singly linked list containing N nodes, the task is to delete all the odd nodes from the list. Examples: Input: 572->112->21->5->1->6 Output: 572 -> 112 -> 6 Explanation: All the odd valued nodes ha
10 min read
Program to delete all even nodes from a Singly Linked List
Given a singly linked list containing N nodes, the task is to delete all the even nodes from the list. Examples: Input: LL = 1 -> 4 -> 3 -> 18 -> 19 Output: 1 -> 3 -> 19Input: LL = 5 -> 3 -> 6 -> 8 -> 4 -> 1 -> 2 -> 9 Output: 5 -> 3 -> 1 -> 9 Approach
15+ min read
Remove all the Even Digit Sum Nodes from a Circular Singly Linked List
Given a circular singly linked list containing N nodes, the task is to remove all the nodes from the list which contains elements whose digit sum is even. Examples: Input: CLL = 9 -> 11 -> 34 -> 6 -> 13 -> 21 Output: 9 -> 34 -> 21 Explanation: The circular singly linked list con
12 min read
Delete every Kth node from circular linked list
Delete every kth node from a circular linked list until only one node is left. Also, print the intermediate lists. Examples: Input : n=4, k=2, list = 1->2->3->4 Output : 1->2->3->4->1 1->2->4->1 2->4->2 2->2 Input : n=9, k=4, list = 1->2->3->4->5-
13 min read
Delete a Linked List node at a given position
Given a singly linked list and a position (1-based indexing), the task is to delete a linked list node at the given position.Note: Position will be valid (i.e, 1 <= position <= linked list length)Example: Input: position = 2, Linked List = 8->2->3->1->7Output: Linked List = 8->3
8 min read
Remove all even parity nodes from a Doubly and Circular Singly Linked List
Given a Doubly linked list and Circular singly linked list containing N nodes, the task is to remove all the nodes from each list which contains elements whose parity is even. Example: Input: CLL = 9 -> 11 -> 34 -> 6 -> 13 -> 21 Output: 11 -> 13 -> 21 Explanation: The circular s
15+ min read
Delete all the even nodes from a Doubly Linked List
Given a doubly linked list containing N nodes, the task is to delete all the even nodes from the list. Examples: Input: Initial List = 15 <=> 16 <=> 6 <=> 7 <=> 17 Output: Final List = 15 <=> 7 <=> 17Explanation: 16 and 6 are even nodes. So we need to delete them.
11 min read
Merge odd and even positioned nodes of two Linked Lists alternately
Given two linked lists L1 and L2, the task is to print a new list obtained by merging odd position nodes of L1 with the even positioned nodes of L2 alternately. Examples: Input: L1 = 8->5->3->2->10->NULL, L2 = 11->13->1->6->9->NULLOutput: 8->13->3->6->10-
15 min read