Eliminar todos los Nodes de posición pares o impares de la lista enlazada circular
Dada una lista enlazada circular única, comenzando desde el primer Node, elimine todos los Nodes de posición impar en ella.
Nota : se considera que la lista vinculada tiene una indexación basada en 1. Es decir, el primer elemento de la lista enlazada está en la posición 1.
Ejemplos :
Input : List = 99->11->22->33 Output : 11->33 Input : List = 90->10->20->30 Output : 10->30
La idea es comenzar a recorrer la lista enlazada circular utilizando una variable de recuento para realizar un seguimiento de la posición del Node actual. Si el Node actual está en una posición impar, elimine ese Node utilizando el enfoque descrito en Eliminar Node de la lista circular enlazada .
Función para eliminar todos los Nodes impares:
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;
}
Java
// 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
C#
// 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
Javascript
<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>
Python3
# 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
Eliminar todos los Nodes de posición par de la lista enlazada circular
Dada una lista enlazada circular única. La tarea es eliminar todos los Nodes en las posiciones pares de esta lista. Eso es todo a partir del segundo Node, elimine todos los Nodes alternativos de la lista.
Ejemplos :
Input : List = 99->11->22->33 Output : 99->22 Input : List = 90->10->20->30 Output : 90->20
Nota : se considera que la lista vinculada tiene una indexación basada en 1. Es decir, el primer elemento de la lista enlazada está en la posición 1.
La idea es comenzar a recorrer la lista enlazada circular utilizando una variable de recuento para realizar un seguimiento de la posición del Node actual. Si el Node actual está en una posición uniforme, elimine ese Node utilizando el enfoque descrito en Eliminar Node de la lista enlazada circular .
Función para eliminar Nodes incluso posicionados:
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;
}
Java
// 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
C#
// 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
Javascript
<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>
Python3
# 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
Programa para eliminar Nodes posicionados pares o impares :
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
// 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#
// 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
Javascript
<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
# 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
Producción:
Initial 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
Complejidad de Tiempo : O(N)
Espacio Auxiliar : O(1)