Circular Singly Linked List - Delete odd nodes

The function deleteOddNodes is created for this purpose. It is a 5-step process.

void deleteOddNodes() {
//1. if head is the only element element in
//   list make the head as null
} else if(head != NULL) {

//2. if the list contains more than one element
//   last element with the new head
temp = temp->next;
}

//3. create evenNode node - pointing to head
//   oddNode node - pointing to next of head
//   temp node - to store last even node

while(true) {

//4. delete odd node and update evenNode and
//   oddNode to next set of odd-even nodes update
//   temp node to latest evenNode node continue
//   the process till any of the node reaches head
temp = evenNode;
evenNode->next = oddNode->next;
free(oddNode);
evenNode = evenNode->next;
oddNode = evenNode->next;
break;
}

//5. if evenNode reaches head, make next of temp
else
}
}
}
//1. if head is the only element element in
//   list make the head as null
} else if(*head_ref != NULL) {

//2. if the list contains more than one element
//   last element with the new head
temp = temp->next;
}

//3. create evenNode node - pointing to head
//   oddNode node - pointing to next of head
//   temp node - to store last even node

while(1) {

//4. delete odd node and update evenNode and
//   oddNode to next set of odd-even nodes update
//   temp node to latest evenNode node continue
//   the process till any of the node reaches head
temp = evenNode;
evenNode->next = oddNode->next;
free(oddNode);
evenNode = evenNode->next;
oddNode = evenNode->next;
break;
}

//5. if evenNode reaches head, make next of temp
else
}
}
}
def deleteOddNodes(self):
#1. if head is the only element element in
#   list make the head as null

#2. if the list contains more than one element
#   last element with the new head
temp = temp.next

#3. create evenNode node - pointing to head
#   oddNode node - pointing to next of head
#   temp node - to store last even node

while(True):

#4. delete odd node and update evenNode and
#   oddNode to next set of odd-even nodes update
#   temp node to latest evenNode node continue
#   the process till any of the node reaches head
temp = evenNode
evenNode.next = oddNode.next
oddNode = None
evenNode = evenNode.next
oddNode = evenNode.next
break

#5. if evenNode reaches head, make next of temp
else:
void deleteOddNodes() {
//1. if head is the only element element in
//   list make the head as null
} else if(this.head != null) {

//2. if the list contains more than one element
//   last element with the new head
temp = temp.next;
}

//3. create evenNode node - pointing to head
//   oddNode node - pointing to next of head
//   temp node - to store last even node

while(true) {

//4. delete odd node and update evenNode and
//   oddNode to next set of odd-even nodes update
//   temp node to latest evenNode node continue
//   the process till any of the node reaches head
temp = evenNode;
evenNode.next = oddNode.next;
oddNode = null;
evenNode = evenNode.next;
oddNode = evenNode.next;
break;
}

//5. if evenNode reaches head, make next of temp
else
}
}
}
public void deleteOddNodes() {
//1. if head is the only element element in
//   list make the head as null
} else if(this.head != null) {

//2. if the list contains more than one element
//   last element with the new head
temp = temp.next;
}

//3. create evenNode node - pointing to head
//   oddNode node - pointing to next of head
//   temp node - to store last even node

while(true) {

//4. delete odd node and update evenNode and
//   oddNode to next set of odd-even nodes update
//   temp node to latest evenNode node continue
//   the process till any of the node reaches head
temp = evenNode;
evenNode.next = oddNode.next;
oddNode = null;
evenNode = evenNode.next;
oddNode = evenNode.next;
break;
}

//5. if evenNode reaches head, make next of temp
else
}
}
}
public function deleteOddNodes() {
//1. if head is the only element element in
//   list make the head as null
} else if(\$this->head != null) {

//2. if the list contains more than one element
//   last element with the new head
\$temp = \$temp->next;
}

//3. create evenNode node - pointing to head
//   oddNode node - pointing to next of head
//   temp node - to store last even node

while(true) {

//4. delete odd node and update evenNode and
//   oddNode to next set of odd-even nodes update
//   temp node to latest evenNode node continue
//   the process till any of the node reaches head
\$temp = \$evenNode;
\$evenNode->next = \$oddNode->next;
\$oddNode = null;
\$evenNode = \$evenNode->next;
\$oddNode = \$evenNode->next;
break;
}

//5. if evenNode reaches head, make next of temp
else
}
}
}

The below is a complete program that uses above discussed concept of deleting odd nodes of a circular singly linked list.

#include <iostream>
using namespace std;

//node structure
struct Node {
int data;
Node* next;
};

private:
public:
}

//Add new element at the end of the list
void push_back(int newElement) {
Node* newNode = new Node();
newNode->data = newElement;
newNode->next = NULL;
} else {
temp = temp->next;
temp->next = newNode;
}
}

//delete odd nodes of the list
void deleteOddNodes() {
} else if(head != NULL) {

temp = temp->next;
}

while(true) {
temp = evenNode;
evenNode->next = oddNode->next;
free(oddNode);
evenNode = evenNode->next;
oddNode = evenNode->next;
break;
}

else
}
}
}

//display the content of the list
void PrintList() {
if(temp != NULL) {
cout<<"The list contains: ";
while(true) {
cout<<temp->data<<" ";
temp = temp->next;
break;
}
cout<<endl;
} else {
cout<<"The list is empty.\n";
}
}
};

// test the code
int main() {

//Add five elements in the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(40);
MyList.push_back(50);

//Display the content of the list.
MyList.PrintList();

//delete odd nodes of the list
MyList.deleteOddNodes();

cout<<"After deleting odd nodes:\n";
//Display the content of the list.
MyList.PrintList();

return 0;
}

The above code will give the following output:

The list contains: 10 20 30 40 50
After deleting odd nodes:
The list contains: 20 40
#include <stdio.h>
#include <stdlib.h>

//node structure
struct Node {
int data;
struct Node* next;
};

//Add new element at the end of the list
void push_back(struct Node** head_ref, int newElement) {
struct Node *newNode, *temp;
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = newElement;
newNode->next = NULL;
} else {
temp = temp->next;
}
temp->next = newNode;
}
}

//delete odd nodes of the list
} else if(*head_ref != NULL) {

temp = temp->next;
}

while(1) {
temp = evenNode;
evenNode->next = oddNode->next;
free(oddNode);
evenNode = evenNode->next;
oddNode = evenNode->next;
break;
}

else
}
}
}

//display the content of the list
printf("The list contains: ");
while (1) {
printf("%i ",temp->data);
temp = temp->next;
break;
}
printf("\n");
} else {
printf("The list is empty.\n");
}
}

// test the code
int main() {
struct Node* MyList = NULL;

//Add five elements in the list.
push_back(&MyList, 10);
push_back(&MyList, 20);
push_back(&MyList, 30);
push_back(&MyList, 40);
push_back(&MyList, 50);

//Display the content of the list.
PrintList(MyList);

//delete odd nodes of the list
deleteOddNodes(&MyList);

printf("After deleting odd nodes:\n");
//Display the content of the list.
PrintList(MyList);

return 0;
}

The above code will give the following output:

The list contains: 10 20 30 40 50
After deleting odd nodes:
The list contains: 20 40
# node structure
class Node:
def __init__(self, data):
self.data = data
self.next = None

def __init__(self):

#Add new element at the end of the list
def push_back(self, newElement):
newNode = Node(newElement)
return
else:
temp = temp.next
temp.next = newNode

#delete odd nodes of the list
def deleteOddNodes(self):

temp = temp.next

while(True):
temp = evenNode
evenNode.next = oddNode.next
oddNode = None
evenNode = evenNode.next
oddNode = evenNode.next
break

else:

#display the content of the list
def PrintList(self):
if(temp != None):
print("The list contains:", end=" ")
while (True):
print(temp.data, end=" ")
temp = temp.next
break
print()
else:
print("The list is empty.")

# test the code

#Add five elements in the list.
MyList.push_back(10)
MyList.push_back(20)
MyList.push_back(30)
MyList.push_back(40)
MyList.push_back(50)

#Display the content of the list.
MyList.PrintList()

#delete odd nodes of the list
MyList.deleteOddNodes()

print("After deleting odd nodes:")
#Display the content of the list.
MyList.PrintList()

The above code will give the following output:

The list contains: 10 20 30 40 50
After deleting odd nodes:
The list contains: 20 40
//node structure
class Node {
int data;
Node next;
};

}

//Add new element at the end of the list
void push_back(int newElement) {
Node newNode = new Node();
newNode.data = newElement;
newNode.next = null;
} else {
Node temp = new Node();
temp = temp.next;
temp.next = newNode;
}
}

//delete odd nodes of the list
void deleteOddNodes() {
} else if(this.head != null) {
temp = temp.next;
}

while(true) {
temp = evenNode;
evenNode.next = oddNode.next;
oddNode = null;
evenNode = evenNode.next;
oddNode = evenNode.next;
break;
}

else
}
}
}

//display the content of the list
void PrintList() {
Node temp = new Node();
if(temp != null) {
System.out.print("The list contains: ");
while(true) {
System.out.print(temp.data + " ");
temp = temp.next;
break;
}
System.out.println();
} else {
System.out.println("The list is empty.");
}
}
};

// test the code
public class Implementation {
public static void main(String[] args) {

//Add five elements in the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(40);
MyList.push_back(50);

//Display the content of the list.
MyList.PrintList();

//delete odd nodes of the list
MyList.deleteOddNodes();

System.out.println("After deleting odd nodes:");
//Display the content of the list.
MyList.PrintList();
}
}

The above code will give the following output:

The list contains: 10 20 30 40 50
After deleting odd nodes:
The list contains: 20 40
using System;

//node structure
class Node {
public int data;
public Node next;
};

}

//Add new element at the end of the list
public void push_back(int newElement) {
Node newNode = new Node();
newNode.data = newElement;
newNode.next = null;
} else {
Node temp = new Node();
temp = temp.next;
temp.next = newNode;
}
}

//delete odd nodes of the list
public void deleteOddNodes() {
} else if(this.head != null) {

temp = temp.next;
}

while(true) {
temp = evenNode;
evenNode.next = oddNode.next;
oddNode = null;
evenNode = evenNode.next;
oddNode = evenNode.next;
break;
}

else
}
}
}

//display the content of the list
public void PrintList() {
Node temp = new Node();
if(temp != null) {
Console.Write("The list contains: ");
while(true) {
Console.Write(temp.data + " ");
temp = temp.next;
break;
}
Console.WriteLine();
} else {
Console.WriteLine("The list is empty.");
}
}
};

// test the code
class Implementation {
static void Main(string[] args) {

//Add five elements in the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(40);
MyList.push_back(50);

//Display the content of the list.
MyList.PrintList();

//delete odd nodes of the list
MyList.deleteOddNodes();

Console.WriteLine("After deleting odd nodes:");
//Display the content of the list.
MyList.PrintList();
}
}

The above code will give the following output:

The list contains: 10 20 30 40 50
After deleting odd nodes:
The list contains: 20 40
<?php
//node structure
class Node {
public \$data;
public \$next;
}

public function __construct(){
}

//Add new element at the end of the list
public function push_back(\$newElement) {
\$newNode = new Node();
\$newNode->data = \$newElement;
\$newNode->next = null;
} else {
\$temp = new Node();
\$temp = \$temp->next;
}
\$temp->next = \$newNode;
}
}

//delete odd nodes of the list
public function deleteOddNodes() {
} else if(\$this->head != null) {

\$temp = \$temp->next;
}

while(true) {
\$temp = \$evenNode;
\$evenNode->next = \$oddNode->next;
\$oddNode = null;
\$evenNode = \$evenNode->next;
\$oddNode = \$evenNode->next;
break;
}

else
}
}
}

//display the content of the list
public function PrintList() {
\$temp = new Node();
if(\$temp != null) {
echo "The list contains: ";
while(true) {
echo \$temp->data." ";
\$temp = \$temp->next;
break;
}
echo "\n";
} else {
echo "The list is empty.\n";
}
}
};

// test the code

//Add five elements in the list.
\$MyList->push_back(10);
\$MyList->push_back(20);
\$MyList->push_back(30);
\$MyList->push_back(40);
\$MyList->push_back(50);

//Display the content of the list.
\$MyList->PrintList();

//delete odd nodes of the list
\$MyList->deleteOddNodes();

echo "After deleting odd nodes:\n";
//Display the content of the list.
\$MyList->PrintList();
?>

The above code will give the following output:

The list contains: 10 20 30 40 50
After deleting odd nodes:
The list contains: 20 40

5