Program to Delete a New Node From the Middle of the Circular Linked List

#Represents the node of list.
class Node:
    def __init__(self,data):
        self.data = data;
        self.next = None;
 
class CreateList:
    #Declaring head and tail pointer as null.
    def __init__(self):
        self.head = Node(None);
        self.tail = Node(None);
        self.head.next = self.tail;
        self.tail.next = self.head;
        self.size = 0;
    
    #This function will add the new node at the end of the list.
    def add(self,data):
        newNode = Node(data);
        #Checks if the list is empty.
        if self.head.data is None:
            #If list is empty, both head and tail would point to new node.
            self.head = newNode;
            self.tail = newNode;
            newNode.next = self.head;
        else:
            #tail will point to new node.
            self.tail.next = newNode;
            #New node will become new tail.
            self.tail = newNode;
            #Since, it is circular linked list tail will point to head.
            self.tail.next = self.head;
        #Size will count the number of nodes in the list
        self.size = int(self.size)+1;
    
    #Deletes node from the middle of the list
    def deleteMid(self):
        #Checks whether list is empty
        if(self.head == None):
            return;
        else:
            #Store the mid position of the list
            count = (self.size//2) if (self.size % 2 == 0) else ((self.size+1)//2);
            #Checks whether head is equal to tail or not, if yes then list has only one node.
            if( self.head != self.tail ):
                #Initially temp will point to head;
                temp = self.head;
                current = None;
                #Current will point to node previous to temp
                #If temp is pointing to node 2 then current will points to node 1.
                for i in range(0, count-1):
                    current = temp;
                    temp = temp.next;
                if(current != None):
                    #temp is the middle that needs to be removed.
                    #So, current node will point to node next to temp by skipping temp.
                    current.next = temp.next;
                    #Delete temp;
                    temp = None;
                #Current points to null then head and tail will point to node next to temp.
                else:
                    self.head = self.tail = temp.next;
                    self.tail.next = self.head;
                    #Delete temp;
                    temp = None;
            #If the list contains only one element 
            #then it will remove it and both head and tail will point to null
            else:
                self.head = self.tail = None;
        self.size = self.size - 1;
 
            
    #Displays all the nodes in the list
    def display(self):
        current = self.head;
        if self.head is None:
            print("List is empty");
            return;
        else:
            #Prints each node by incrementing pointer.
            print(current.data),
            while(current.next != self.head):
                current = current.next;
                print(current.data),
            print("\n");
 
class CircularLinkedList:
    cl = CreateList();
    #Adds data to the list
    cl.add(1);
    cl.add(2);
    cl.add(3);
    cl.add(4);
    #Printing original list
    print("Original List:");
    cl.display();
    while(cl.head != None):
        cl.deleteMid();
        #Printing updated list
        print("Updated List:");
        cl.display();

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
//Represents the node of list.
struct node{
    int data;
    struct node *next;
};
 
int size;
//Declaring head and tail pointer as null.
struct node *head = NULL;
struct node *tail = NULL;
 
//This function will add the new node at the end of the list.
void add(int data){
    //Create new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    //Checks if the list is empty.
    if(head == NULL){
        //If list is empty, both head and tail would point to new node.
        head = newNode;
        tail = newNode;
        newNode->next = head;
    }else {
        //tail will point to new node.
        tail->next = newNode;
        //New node will become new tail.
        tail = newNode;
        //Since, it is circular linked list tail will point to head.
        tail->next = head;
    }
    //Counts the number of nodes in list
    size++;
}
 
//Deletes node from the middle of the list
void deleteMid() {
    struct node *current, *temp;
    //Checks whether list is empty
    if(head == NULL) {
        return;
    }
    else {
        //Store the mid position of the list
        int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
        //Checks whether head is equal to tail or not, if yes then list has only one node.
        if( head != tail ) {
            //Initially temp will point to head;
            temp = head;
            current = NULL;
            //Current will point to node previous to temp
            //If temp is pointing to node 2 then current will points to node 1.
            for(int i = 0; i < count-1; i++){
                current = temp;
                temp = temp->next;
            }
            
            if(current != NULL) {
                //temp is the middle that needs to be removed.
                //So, current node will point to node next to temp by skipping temp.
                current->next = temp->next;
                //Delete temp;
                temp = NULL;
            }
            //Current points to null then head and tail will point to node next to temp.
            else {
                head = tail = temp->next;
                tail->next = head;
                //Delete temp;
                temp = NULL;
            }
            
        }
        //If the list contains only one element 
        //then it will remove it and both head and tail will point to null
        else {
            head = tail = NULL;
        }
    }
    size--;
}
    
//This function will display the nodes of circular linked list
void display(){
    struct node *current = head;
    if(head == NULL){
        printf("List is empty");
    }
    else{
         do{
             //Prints each node by incrementing pointer.
            printf("%d ", current->data);
            current = current->next;
        }while(current != head);
        printf("\n");
    }
}
    
int main()
{
   //Adds data to the list
   add(1);
   add(2);
   add(3);
   add(4);
   //Printing original list
   printf("Original List:\n ");
   display();
   while(head != NULL) {
        deleteMid();
        //Printing updated list
        printf("Updated List:\n ");
        display();
    }
   
   return 0;
}

public class DeleteMid {
    //Represents the node of list.
    public class Node{
        int data;
        Node next;
        public Node(int data) {
            this.data = data;
        }
    }
    
    public int size;
    //Declaring head and tail pointer as null.
    public Node head = null;
    public Node tail = null;
    
    //This function will add the new node at the end of the list.
    public void add(int data){
        //Create new node
        Node newNode = new Node(data);
        //Checks if the list is empty.
        if(head == null) {
             //If list is empty, both head and tail would point to new node.
            head = newNode;
            tail = newNode;
            newNode.next = head;
        }
        else {
            //tail will point to new node.
            tail.next = newNode;
            //New node will become new tail.
            tail = newNode;
            //Since, it is circular linked list tail will point to head.
            tail.next = head;
        }
        //Counts the number of nodes in list
        size++;
    }
    
    //Deletes node from the middle of the list
    public void deleteMid() {
        Node current, temp;
        //Checks whether list is empty
        if(head == null) {
            return;
        }
        else {
            //Store the mid position of the list
            int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
            //Checks whether head is equal to tail or not, if yes then list has only one node.
            if( head != tail ) {
                //Initially temp will point to head;
                temp = head;
                current = null;
                //Current will point to node previous to temp
                //If temp is pointing to node 2 then current will points to node 1.
                for(int i = 0; i < count-1; i++){
                    current = temp;
                    temp = temp.next;
                }
                
                if(current != null) {
                    //temp is the middle that needs to be removed.
                    //So, current node will point to node next to temp by skipping temp.
                    current.next = temp.next;
                    //Delete temp;
                    temp = null;
                }
                //Current points to null then head and tail will point to node next to temp.
                else {
                    head = tail = temp.next;
                    tail.next = head;
                    //Delete temp;
                    temp = null;
                }
                
            }
            //If the list contains only one element 
            //then it will remove it and both head and tail will point to null
            else {
                head = tail = null;
            }
        }
        size--;
    }
    
    //Displays all the nodes in the list
    public void display() {
        Node current = head;
        if(head == null) {
            System.out.println("List is empty");
        }
        else {
             do{
                //Prints each node by incrementing pointer.
                System.out.print(" "+ current.data);
                current = current.next;
            }while(current != head);
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        DeleteMid cl = new DeleteMid();
        //Adds data to the list
        cl.add(1);
        cl.add(2);
        cl.add(3);
        cl.add(4);
        //Printing original list
        System.out.println("Original List: ");
        cl.display();
        while(cl.head != null) {
            cl.deleteMid();
            //Printing updated list
            System.out.println("Updated List: ");
            cl.display();
        }
    }
}

using System; 
namespace CircularLinkedList 
{                     
    public class Program
    {
        //Represents the node of list.
        public class Node<T>{
            public T data;
            public Node<T> next;
            public Node(T value) {
                data = value;
                next = null;
            }
        }
        
        public class CreateList<T>{
            public int size = 0;
            public Node<T> head = null;             
             public Node<T> tail = null;
            
            //This function will add the new node at the end of the list.
            public void add(T data){
                //Create new node
                Node<T> newNode = new Node<T>(data);
                //Checks if the list is empty.
                if(head == null){
                    head = newNode;
                    tail = newNode;
                    newNode.next = head;
                }else{
                    //tail will point to new node.
                    tail.next = newNode;
                    //New node will become new tail.
                    tail = newNode;
                    //Since, it is circular linked list tail will point to head.
                    tail.next = head;
                }
                //Counts the number of nodes in the list
                size++;
            }
            
            //Deletes node from the middle of the list
            public void deleteMid() {
                Node<T> current, temp;
                //Checks whether list is empty
                if(head == null) {
                    return;
                }
                else {
                    //Store the mid position of the list
                    int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
                    //Checks whether head is equal to tail or not, if yes then list has only one node.
                    if( head != tail ) {
                        //Initially temp will point to head;
                        temp = head;
                        current = null;
                        //Current will point to node previous to temp
                        //If temp is pointing to node 2 then current will points to node 1.
                        for(int i = 0; i < count-1; i++){
                            current = temp;
                            temp = temp.next;
                        }
                        
                        if(current != null) {
                            //temp is the middle that needs to be removed.
                            //So, current node will point to node next to temp by skipping temp.
                            current.next = temp.next;
                            //Delete temp;
                            temp = null;
                        }
                        //Current points to null then head and tail will point to node next to temp.
                        else {
                            head = tail = temp.next;
                            tail.next = head;
                            //Delete temp;
                            temp = null;
                        }
                        
                    }
                    //If the list contains only one element 
                    //then it will remove it and both head and tail will point to null
                    else {
                        head = tail = null;
                    }
                }
                size--;
            }
            
            //Displays all the nodes in the list
            public void display(){
                Node<T> current = head;
                if(head == null){
                    Console.WriteLine("List is empty");
                }
                else{
                    do{
                        //Prints each node by incrementing pointer.
                        Console.Write(" "+ current.data);
                        current = current.next;
                    }while(current != head);
                    Console.WriteLine();
                }
            }
        }
        
        public static void Main()
        {
            
        CreateList<int> cl = new CreateList<int>();
        //Adds data to the list
        cl.add(1);
        cl.add(2);
        cl.add(3);
        cl.add(4);
        //Printing original list
        Console.WriteLine("Original List: ");
        cl.display();
        while(cl.head != null) {
            cl.deleteMid();
            //Printing updated list
            Console.WriteLine("Updated List: ");
            cl.display();
        }
        }    
    }
}

<!DOCTYPE html>
<html>
<body>
<?php
//Represents the node of list.
class Node{
    public $data;
    public $next;
    function __construct($data){
        $this->data = $data;
        $this->next = NULL;
    }
}
class CreateList{
    //Declaring head and tail pointer as null.
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
        $this->size = 0;
    }
    //This function will add the new node at the end of the list.
    function add($data){
        //Create new node
        $newNode = new Node($data);
        //Checks if the list is empty.
        if($this->head == NULL){
            //If list is empty, both head and tail would point to new node.
            $this->head = $newNode;
            $this->tail = $newNode;
            $newNode->next = $this->head;
        }
        else{
            //tail will point to new node.
            $this->tail->next = $newNode;
            //New node will become new tail.
            $this->tail = $newNode;
            //Since, it is circular linked list tail will point to head.
            $this->tail->next = $this->head;
        }
        $this->size++;
    }
    
    //Deletes node from the middle of the list
    function deleteMid() {
        //Checks whether list is empty
        if($this->head == NULL) {
            return;
        }
        else {
            //Store the mid position of the list
            $count = ($this->size % 2 == 0) ? ($this->size/2) : (($this->size+1)/2);
            //Checks whether head is equal to tail or not, if yes then list has only one node.
            if( $this->head != $this->tail ) {
                //Initially temp will point to head;
                $temp = $this->head;
                $current = NULL;
                //Current will point to node previous to temp
                //If temp is pointing to node 2 then current will points to node 1.
                for($i = 0; $i < $count-1; $i++){
                    $current = $temp;
                    $temp = $temp->next;
                }
                
                if($current != NULL) {
                    //temp is the middle that needs to be removed.
                    //So, current node will point to node next to temp by skipping temp.
                    $current->next = $temp->next;
                    //Delete temp;
                    $temp = NULL;
                }
                //Current points to null then head and tail will point to node next to temp.
                else {
                    $this->head = $this->tail = $temp->next;
                    $this->tail->next = $this->head;
                    //Delete temp;
                    $temp = NULL;
                }
                
            }
            //If the list contains only one element 
            //then it will remove it and both head and tail will point to null
            else {
                $this->head = $this->tail = NULL;
            }
        }
        $this->size--;
    }
    
    //Displays all the nodes in the list
    function display() {
        $current = $this->head;
        if($this->head == NULL) {
            echo "List is empty";
        }
        else {
             do{
                //Prints each node by incrementing pointer.
                echo(" $current->data");
                $current = $current->next;
            }while($current != $this->head);
            echo "<br>";
        }
    }   
}
$cl = new CreateList();
//Adds data to the list
$cl->add(1);
$cl->add(2);
$cl->add(3);
$cl->add(4);
//Printing original list
echo "Original List:<br>";
$cl->display();
while($cl->head != NULL) {
    $cl->deleteMid();
    //Printing updated list
    echo "Updated List:<br>";
    $cl->display();
}
?>
</body>
</html>