Eliminación en diferentes posiciones en una lista enlazada circular

Dada una lista enlazada circular. La tarea es escribir programas para eliminar Nodes de esta lista presente en: 

• Primera posición.
• Ultima posicion.
• En cualquier puesto dado  .

Eliminación del primer Node de la lista enlazada circular única

Ejemplos :  

Input : 99->11->22->33->44->55->66
Output : 11->22->33->44->55->66

Input : 11->22->33->44->55->66
Output : 22->33->44->55->66

Eliminación del primer Node de la lista enlazada circular

Enfoque : 

1. Tome dos punteros actuales y anteriores y recorra la lista.
2. Mantenga el puntero actual fijo apuntando al primer Node y avance hasta llegar al último Node.
3. Una vez que el puntero anterior llegue al último Node, haga lo siguiente: 
   • anterior->siguiente = actual->siguiente
   • cabeza = anterior -> siguiente;

Función para eliminar el primer Node de la lista enlazada circular única :  

// Function to delete First node of
// Circular Linked List
void DeleteFirst(struct Node** head)
{
    struct Node *previous = *head, *firstNode = *head;
  
    // check if list doesn't have any node
    // if not then return
    if (*head == NULL) {
        printf("\nList is empty\n");
        return;
    }
  
    // check if list have single node
    // if yes then delete it and return
    if (previous->next == previous) {
        *head = NULL;
        return;
    }
  
    // traverse second node to first
    while (previous->next != *head) {
  
        previous = previous->next;
    }
  
    // now previous is last node and
    // first node(firstNode) link address
    // put in last node(previous) link
    previous->next = firstNode->next;
  
    // make second node as head node
    *head = previous->next;
    free(firstNode);
    return;
}

// Function to delete First node of
// Circular Linked List
static void DeleteFirst(Node head)
{
    Node previous = head, firstNode = head;
  
    // Check if list doesn't have any node
    // if not then return
    if (head == null) 
    {
        System.out.printf("\nList is empty\n");
        return;
    }
  
    // Check if list have single node
    // if yes then delete it and return
    if (previous.next == previous)
    {
        head = null;
        return;
    }
  
    // Traverse second node to first
    while (previous.next != head) 
    {
        previous = previous.next;
    }
  
    // Now previous is last node and
    // first node(firstNode) link address
    // put in last node(previous) link
    previous.next = firstNode.next;
  
    // Make second node as head node
    head = previous.next;
    System.gc();
    return;
}
  
// This code is contributed by aashish1995

# Function 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 None
      
    # check list have single node
    # if yes then delete it and return
    if (previous.next == previous) :
      
        head = None
        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
    
# This code is contributed by shivanisinghss2110

using System;
  
public class GFG{
  
    static public// Function 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 null; 
    } 
  
    // Check if list have single node
    // if yes then delete it and return
    if (previous.next == previous) 
    { 
        head = null; 
        return null; 
    } 
  
    // Traverse second node to first 
    while (previous.next != head) 
    { 
        previous = previous.next; 
        next = previous.next; 
    } 
  
    // Now previous is last node and
    // first node(firstNode) link address
    // put in last node(previous) link
    previous.next = next.next; 
  
    // Make second node as head node
    head = previous.next; 
  
    return head; 
} 
// This code is contributed by shivanisinghss2110.
c void Main (){
  
        // Code
    }

<script>
  
function  DeleteFirst(head)
{
    previous = head, firstNode = head;
   
    // Check if list doesn't have any node
    // if not then return
    if (head == null)
    {
        document.write("<br>List is empty<br>");
        return;
    }
   
    // Check if list have single node
    // if yes then delete it and return
    if (previous.next == previous)
    {
        head = null;
        return;
    }
   
    // Traverse second node to first
    while (previous.next != head)
    {
        previous = previous.next;
    }
   
    // Now previous is last node and
    // first node(firstNode) link address
    // put in last node(previous) link
    previous.next = firstNode.next;
   
    // Make second node as head node
    head = previous.next;
      
    return;
}
  
// This code is contributed by rag2127
</script>

Eliminación del último Node de la Lista enlazada circular

Ejemplos : 

Input : 99->11->22->33->44->55->66
Output : 99->11->22->33->44->55

Input : 99->11->22->33->44->55
Output : 99->11->22->33->44

Eliminar el último Node de la lista enlazada circular

Enfoque : 

1. Tome dos punteros actuales y anteriores y recorra la lista.
2. Mueva ambos punteros de modo que el siguiente del anterior siempre apunte al actual. Siga moviendo los punteros actual y anterior hasta que actual llegue al último Node y anterior esté en el penúltimo Node.
3. Una vez que la corriente del puntero llegue al último Node, haga lo siguiente: 
   • anterior->siguiente = actual->siguiente
   • cabeza = anterior -> siguiente;

Función para eliminar el último Node de la lista : 

// Function delete last node of
// Circular Linked List
void DeleteLast(struct Node** head)
{
    struct Node *current = *head, *temp = *head, *previous;
  
    // check if list doesn't have any node
    // if not then return
    if (*head == NULL) {
        printf("\nList is empty\n");
        return;
    }
  
    // check if list have single node
    // if yes then delete it and return
    if (current->next == current) {
        *head = NULL;
        return;
    }
  
    // move first node to last
    // previous
    while (current->next != *head) {
        previous = current;
        current = current->next;
    }
  
    previous->next = current->next;
    *head = previous->next;
    free(current);
    return;
}

// Function to delete last node of
// Circular Linked List
static Node DeleteLast(Node head)
{
    Node current = head, temp = head, previous = null;
   
    // Check if list doesn't have any node
    // if not then return
    if (head == null)
    {
        System.out.printf("\nList is empty\n");
        return null;
    }
   
    // Check if list have single node
    // if yes then delete it and return
    if (current.next == current) 
    {
        head = null;
        return null;
    }
   
    // Move first node to last
    // previous
    while (current.next != head)
    {
        previous = current;
        current = current.next;
    }
   
    previous.next = current.next;
    head = previous.next;
       
    return head;
}
  
// This code is contributed by pratham76

# Function to delete last node of
# Circular Linked List
def DeleteLast(head):
    current = head
    temp = head
    previous = None
  
    # check if list doesn't have any node
    # if not then return
    if (head == None):
        print("\nList is empty")
        return None
  
    # check if list have single node
    # if yes then delete it and return
    if (current.next == current):
        head = None
        return None
  
    # move first node to last
    # previous
    while (current.next != head):
        previous = current
        current = current.next
  
    previous.next = current.next
    head = previous.next
  
    return head
  
  # This code is contributed by rutvik_56

// Function to delete last node of 
// Circular Linked List 
static Node DeleteLast(Node head) 
{ 
    Node current = head, temp = head, previous = null; 
  
    // check if list doesn't have any node 
    // if not then return 
    if (head == null) 
    { 
        Console.Write("\nList is empty\n"); 
        return null; 
    } 
  
    // check if list have single node 
    // if yes then delete it and return 
    if (current.next == current) 
    { 
        head = null; 
        return null; 
    } 
  
    // move first node to last 
    // previous 
    while (current.next != head) 
    { 
        previous = current; 
        current = current.next; 
    } 
  
    previous.next = current.next; 
    head = previous.next; 
      
    return head; 
} 
  
// This code is contributed by shivanisinghss2110

<script>
  
function DeleteLast(head)
{
    let current = head, temp = head, previous = null;
    
    // Check if list doesn't have any node
    // if not then return
    if (head == null)
    {
        document.write("<br>List is empty<br>");
        return null;
    }
    
    // Check if list have single node
    // if yes then delete it and return
    if (current.next == current)
    {
        head = null;
        return null;
    }
    
    // Move first node to last
    // previous
    while (current.next != head)
    {
        previous = current;
        current = current.next;
    }
    
    previous.next = current.next;
    head = previous.next;
        
    return head;
}
  
// This code is contributed by avanitrachhadiya2155
  
</script>

Eliminación de Nodes en un índice dado en la lista enlazada circular

Ejemplos : 

Input : 99->11->22->33->44->55->66
        Index= 4
Output : 99->11->22->33->55->66

Input : 99->11->22->33->44->55->66
        Index= 2
Output : 99->11->33->44->55->66

Nota : la indexación basada en 0 se considera para la lista.

Enfoque : 

1. Primero, encuentre la longitud de la lista. Es decir, el número de Nodes en la lista.
2. Tome dos punteros anterior y actual para recorrer la lista. De tal manera que el anterior está una posición detrás del Node actual.
3. Tome un recuento de variables inicializado en 0 para realizar un seguimiento de la cantidad de Nodes atravesados.
4. Recorra la lista hasta alcanzar el índice dado.
5. Una vez que se alcanza el índice dado, haga anterior->siguiente = actual->siguiente .

Función para eliminar un Node en un índice o ubicación dados de una lista enlazada circular única : 

// Function to delete node at given index
// of Circular Linked List
void DeleteAtPosition(struct Node** head, int index)
{
    // find length of list
    int len = Length(*head);
    int count = 1;
    struct Node *previous = *head, *next = *head;
  
    // check if list doesn't have any node
    // if not then return
    if (*head == NULL) {
        printf("\nDelete Last List is empty\n");
        return;
    }
  
    // given index is in list or not
    if (index >= len || index < 0) {
        printf("\nIndex is not Found\n");
        return;
    }
  
    // delete first node
    if (index == 0) {
        DeleteFirst(head);
        return;
    }
  
    // traverse first to last node
    while (len > 0) {
  
        // if index found delete that node
        if (index == count) {
            previous->next = next->next;
            free(next);
            return;
        }
        previous = previous->next;
        next = previous->next;
        len--;
        count++;
    }
  
    return;
}

// Java program to delete node at different
  
// Function delete node at a given position
// of Circular Linked List
static Node DeleteAtPosition( Node head, int index)
{
    // Find length of list
    int len = Length(head);
    int count = 1;
    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;
    }
  
    // given index is in list or not
    if (index >= len || index < 0) 
    {
        System.out.printf("\nIndex is not Found\n");
        return null;
    }
  
    // delete first node
    if (index == 0) 
    {
        head = DeleteFirst(head);
        return head;
    }
  
    // traverse first to last node
    while (len > 0)
    {
  
        // if index found delete that node
        if (index == count)
        {
            previous.next = next.next;
              
            return head;
        }
        previous = previous.next;
        next = previous.next;
        len--;
        count++;
    }
    return head;
}
  
// This code is contributed by shivanisinghss2110

# Function delete node at a given position
# of Circular Linked List
def DeleteAtPosition(head, index):
  
    # Find length of list
    len = Length(head)
    count = 1
    previous = head
    next = head
  
    # check list have any node
    # if not then return
    if (head == None):
        print("\nDelete Last List is empty")
        return None
      
    # given index is in list or not
    if (index >= len or index < 0) :
        print("\nIndex is not Found")
        return None
  
    # delete first node
    if (index == 0) :
        head = DeleteFirst(head)
        return head
  
    # traverse first to last node
    while (len > 0):
      
        # if index found delete that node
        if (index == count):
            previous.next = next.next
              
            return head
          
        previous = previous.next
        next = previous.next
        len = len - 1
        count = count + 1
      
    return head   
  
# This code is contributed by shivanisinghss2110

<script>
  
// Function delete node at a given position
// of Circular Linked List
function DeleteAtPosition(head, index){
  
    // Find length of list
    let len = head.length
    let count = 1
    let previous = head
    let next = head
  
    // check list have any node
    // if not then return
    if (head == null){
        document.write("</br>","Delete Last List is empty")
        return null
    }
      
    // given index is in list or not
    if (index >= len || index < 0){
        document.write("</br>","Index is not Found")
        return null
    }
  
    // delete first node
    if (index == 0){
        head = DeleteFirst(head)
        return head
    }
  
    // traverse first to last node
    while (len > 0){
      
        // if index found delete that node
        if (index == count){
            previous.next = next.next
              
            return head
        }
          
        previous = previous.next
        next = previous.next
        len = len - 1
        count = count + 1
    }
      
    return head 
}  
  
// This code is contributed by shinjanpatra
  
</script>

Programa que implementa las tres funciones anteriores

// C++ program to delete node at different
// positions from a circular linked list
#include <bits/stdc++.h>
using namespace std;
  
// structure for a node
struct Node {
    int data;
    struct Node* next;
};
  
// 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;
    }
}
  
// 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 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 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 last node of
// Circular Linked List
void DeleteLast(struct Node** head)
{
    struct Node *current = *head, *temp = *head, *previous;
  
    // check if list doesn't have any node
    // if not then return
    if (*head == NULL) {
        printf("\nList is empty\n");
        return;
    }
  
    // check if list have single node
    // if yes then delete it and return
    if (current->next == current) {
        *head = NULL;
        return;
    }
  
    // move first node to last
    // previous
    while (current->next != *head) {
        previous = current;
        current = current->next;
    }
  
    previous->next = current->next;
    *head = previous->next;
    free(current);
  
    return;
}
  
// Function delete node at a given position
// of Circular Linked List
void DeleteAtPosition(struct Node** head, int index)
{
    // Find length of list
    int len = Length(*head);
    int count = 1;
    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;
    }
  
    // given index is in list or not
    if (index >= len || index < 0) {
        printf("\nIndex is not Found\n");
        return;
    }
  
    // delete first node
    if (index == 0) {
        DeleteFirst(head);
        return;
    }
  
    // traverse first to last node
    while (len > 0) {
  
        // if index found delete that node
        if (index == count) {
            previous->next = next->next;
            free(next);
            return;
        }
        previous = previous->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 Node at position
    printf("Initial List: ");
    Display(head);
    printf("\nAfter Deleting node at index 4: ");
    DeleteAtPosition(&head, 4);
    Display(head);
  
    // Deleting first Node
    printf("\n\nInitial List: ");
    Display(head);
    printf("\nAfter Deleting first node: ");
    DeleteFirst(&head);
    Display(head);
  
    // Deleting last Node
    printf("\n\nInitial List: ");
    Display(head);
    printf("\nAfter Deleting last node: ");
    DeleteLast(&head);
    Display(head);
  
    return 0;
}

// Java program to delete node at different
// positions from a circular linked list
import java.util.*;
import java.lang.*;
import java.io.*;
  
class GFG
{
  
// structure for a node
static class Node 
{
    int data;
    Node next;
};
  
// 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;
}
  
// 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 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 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 null;
    }
  
    // check list have single node
    // if yes then delete it and return
    if (previous.next == previous) 
    {
        head = null;
        return null;
    }
  
    // 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 last node of
// Circular Linked List
static Node DeleteLast(Node head)
{
    Node current = head, temp = head, previous=null;
  
    // check if list doesn't have any node
    // if not then return
    if (head == null)
    {
        System.out.printf("\nList is empty\n");
        return null;
    }
  
    // check if list have single node
    // if yes then delete it and return
    if (current.next == current) 
    {
        head = null;
        return null;
    }
  
    // move first node to last
    // previous
    while (current.next != head)
    {
        previous = current;
        current = current.next;
    }
  
    previous.next = current.next;
    head = previous.next;
      
    return head;
}
  
// Function delete node at a given position
// of Circular Linked List
static Node DeleteAtPosition( Node head, int index)
{
    // Find length of list
    int len = Length(head);
    int count = 1;
    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;
    }
  
    // given index is in list or not
    if (index >= len || index < 0) 
    {
        System.out.printf("\nIndex is not Found\n");
        return null;
    }
  
    // delete first node
    if (index == 0) 
    {
        head = DeleteFirst(head);
        return head;
    }
  
    // traverse first to last node
    while (len > 0)
    {
  
        // if index found delete that node
        if (index == count)
        {
            previous.next = next.next;
              
            return head;
        }
        previous = previous.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 Node at position
    System.out.printf("Initial List: ");
    Display(head);
    System.out.printf("\nAfter Deleting node at index 4: ");
    head = DeleteAtPosition(head, 4);
    Display(head);
  
    // Deleting first Node
    System.out.printf("\n\nInitial List: ");
    Display(head);
    System.out.printf("\nAfter Deleting first node: ");
    head = DeleteFirst(head);
    Display(head);
  
    // Deleting last Node
    System.out.printf("\n\nInitial List: ");
    Display(head);
    System.out.printf("\nAfter Deleting last node: ");
    head = DeleteLast(head);
    Display(head);
}
}
  
// This code is contributed by Arnab Kundu

# Python3 program to delete node at different
# positions from a circular linked list
  
# A linked list node
class Node: 
    def __init__(self, new_data): 
        self.data = new_data 
        self.next = None
        self.prev = None
  
# 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(0)
  
    # check node is created or not
    if (newNode == None):
      
        print("\nMemory Error\n")
        return None
      
    # 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 == None) :
        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
  
# 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\n")
        return
      
    # traverse first to last node
    else:
      
        while(True):
          
            print( current.data,end=" ")
            current = current.next
            if (current == head):
                break;
      
# 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 = count + 1
            if (current == head):
                break;
      
    return count
  
# Function 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 None
      
    # check list have single node
    # if yes then delete it and return
    if (previous.next == previous) :
      
        head = None
        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 last node of
# Circular Linked List
def DeleteLast(head):
    current = head
    temp = head
    previous = None
  
    # check if list doesn't have any node
    # if not then return
    if (head == None):
        print("\nList is empty")
        return None
  
    # check if list have single node
    # if yes then delete it and return
    if (current.next == current) :
        head = None
        return None
  
    # move first node to last
    # previous
    while (current.next != head):
        previous = current
        current = current.next
      
    previous.next = current.next
    head = previous.next
      
    return head
  
# Function delete node at a given position
# of Circular Linked List
def DeleteAtPosition(head, index):
  
    # Find length of list
    len = Length(head)
    count = 1
    previous = head
    next = head
  
    # check list have any node
    # if not then return
    if (head == None):
        print("\nDelete Last List is empty")
        return None
      
    # given index is in list or not
    if (index >= len or index < 0) :
        print("\nIndex is not Found")
        return None
  
    # delete first node
    if (index == 0) :
        head = DeleteFirst(head)
        return head
  
    # traverse first to last node
    while (len > 0):
      
        # if index found delete that node
        if (index == count):
            previous.next = next.next
              
            return head
          
        previous = previous.next
        next = previous.next
        len = len - 1
        count = count + 1
      
    return head
  
# Driver Code
  
head = None
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 Node at position
print("Initial List: ")
Display(head)
print("\nAfter Deleting node at index 4: ")
head = DeleteAtPosition(head, 4)
Display(head)
  
# Deleting first Node
print("\n\nInitial List: ")
Display(head)
print("\nAfter Deleting first node: ")
head = DeleteFirst(head)
Display(head)
  
# Deleting last Node
print("\n\nInitial List: ")
Display(head)
print("\nAfter Deleting last node: ")
head = DeleteLast(head)
Display(head)
  
# This code is contributed by Arnab Kundu

// C# program to delete node at different 
// positions from a circular linked list 
using System;
  
class GFG 
{ 
  
// structure for a node 
class Node 
{ 
    public int data; 
    public Node next; 
}; 
  
// 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; 
} 
  
// 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 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 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 null; 
    } 
  
    // check list have single node 
    // if yes then delete it and return 
    if (previous.next == previous) 
    { 
        head = null; 
        return null; 
    } 
  
    // 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 last node of 
// Circular Linked List 
static Node DeleteLast(Node head) 
{ 
    Node current = head, temp = head, previous = null; 
  
    // check if list doesn't have any node 
    // if not then return 
    if (head == null) 
    { 
        Console.Write("\nList is empty\n"); 
        return null; 
    } 
  
    // check if list have single node 
    // if yes then delete it and return 
    if (current.next == current) 
    { 
        head = null; 
        return null; 
    } 
  
    // move first node to last 
    // previous 
    while (current.next != head) 
    { 
        previous = current; 
        current = current.next; 
    } 
  
    previous.next = current.next; 
    head = previous.next; 
      
    return head; 
} 
  
// Function delete node at a given position 
// of Circular Linked List 
static Node DeleteAtPosition( Node head, int index) 
{ 
    // Find length of list 
    int len = Length(head); 
    int count = 1; 
    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; 
    } 
  
    // given index is in list or not 
    if (index >= len || index < 0) 
    { 
        Console.Write("\nIndex is not Found\n"); 
        return null; 
    } 
  
    // delete first node 
    if (index == 0) 
    { 
        head = DeleteFirst(head); 
        return head; 
    } 
  
    // traverse first to last node 
    while (len > 0) 
    { 
  
        // if index found delete that node 
        if (index == count) 
        { 
            previous.next = next.next; 
              
            return head; 
        } 
        previous = previous.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 Node at position 
    Console.Write("Initial List: "); 
    Display(head); 
    Console.Write("\nAfter Deleting node at index 4: "); 
    head = DeleteAtPosition(head, 4); 
    Display(head); 
  
    // Deleting first Node 
    Console.Write("\n\nInitial List: "); 
    Display(head); 
    Console.Write("\nAfter Deleting first node: "); 
    head = DeleteFirst(head); 
    Display(head); 
  
    // Deleting last Node 
    Console.Write("\n\nInitial List: "); 
    Display(head); 
    Console.Write("\nAfter Deleting last node: "); 
    head = DeleteLast(head); 
    Display(head); 
} 
} 
  
// This code is contributed by Rajput-Ji

<script>
  
// JavaScript program to delete node at different
// positions from a circular linked list
  
// A linked list node
class Node{
    constructor(new_data){
        this.data = new_data 
        this.next = null
        this.prev = null
    }
}
  
// Function to insert a node at the end of
// a Circular linked list
function Insert(head, data){
  
    let current = head
      
    // Create a new node
    let newNode = new Node(0)
  
    // 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
}
  
// Function document.write data of list
function Display(head){
  
    let 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{
      
        while(true){
          
            document.write( current.data," ")
            current = current.next
            if (current == head)
                break;
        }
    }
}
      
// Function return number of nodes present in list
function Length(head){
    let current = head
    let count = 0
  
    // if list is empty 
    // simply return length zero
    if (head == null)
      
        return 0
  
    // traverse first to last node
    else{
      
        while(true){
          
            current = current.next
            count = count + 1
            if (current == head)
                break;
        }
  
    }
      
    return count
}
  
// Function delete First node of
// Circular Linked List
function DeleteFirst(head){
    let previous = head
    let next = head
  
    // check list have any node
    // if not then return
    if (head == null){
      
        document.write("</br>","List is empty")
        return null
    }
      
    // check list have single node
    // if yes then delete it and return
    if (previous.next == previous){
      
        head = null
        return null
    }
      
    // 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 last node of
// Circular Linked List
function DeleteLast(head){
    let current = head
    let temp = head
    let previous = null
  
    // check if list doesn't have any node
    // if not then return
    if (head == null){
        document.write("</br>","List is empty")
        return null
    }
  
    // check if list have single node
    // if yes then delete it and return
    if (current.next == current){
        head = null
        return null
    }
  
    // move first node to last
    // previous
    while (current.next != head){
        previous = current
        current = current.next
    }
      
    previous.next = current.next
    head = previous.next
      
    return head
}
  
// Function delete node at a given position
// of Circular Linked List
function DeleteAtPosition(head, index){
  
    // Find length of list
    len = Length(head)
    count = 1
    previous = head
    next = head
  
    // check list have any node
    // if not then return
    if (head == null){
        document.write("</br>","Delete Last List is empty")
        return null
    }
      
    // given index is in list or not
    if (index >= len || index < 0) {
        document.write("</br>","Index is not Found")
        return null
    }
  
    // delete first node
    if (index == 0){
        head = DeleteFirst(head)
        return head
    }
  
    // traverse first to last node
    while (len > 0){
      
        // if index found delete that node
        if (index == count){
            previous.next = next.next
              
            return head
        }
          
        previous = previous.next
        next = previous.next
        len = len - 1
        count = count + 1
    }
    return head
}
  
// Driver Code
  
let 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 Node at position
document.write("Initial List: ")
Display(head)
document.write("</br>","After Deleting node at index 4: ")
head = DeleteAtPosition(head, 4)
Display(head)
  
// Deleting first Node
document.write("</br>","</br>","Initial List: ")
Display(head)
document.write("</br>","After Deleting first node: ")
head = DeleteFirst(head)
Display(head)
  
// Deleting last Node
document.write("</br>","</br>","Initial List: ")
Display(head)
document.write("</br>","After Deleting last node: ")
head = DeleteLast(head)
Display(head)
  
// This code is contributed by shinjanpatra
  
</script>

Initial List: 99 11 22 33 44 55 66 
After Deleting node at index 4: 99 11 22 33 55 66 

Initial List: 99 11 22 33 55 66 
After Deleting first node: 11 22 33 55 66 

Initial List: 11 22 33 55 66 
After Deleting last node: 11 22 33 55