Insertion at Specific Position in a Circular Doubly Linked List

// C# program to convert insert 
// an element at a specific position 
// in a circular doubly linked listing, 
// end and middle 
using System;

class GFG 
{ 

// Doubly linked list node 
public class node 
{ 
    public int data; 
    public node next; 
    public node prev; 
}; 

// Utility function to create a node in memory 
static node getNode() 
{ 
    return new node(); 
} 

// Function to display the list 
static int displayList( node temp) 
{ 
    node t = temp; 
    if (temp == null) 
        return 0; 
    else
    { 
        Console.WriteLine( "The list is: "); 

        while (temp.next != t) 
        { 
            Console.Write( temp.data + " "); 
            temp = temp.next; 
        } 

        Console.WriteLine( temp.data ); 

        return 1; 
    } 
} 

// Function to count number of 
// elements in the list 
static int countList( node start) 
{ 
    // Declare temp pointer to 
    // traverse the list 
    node temp = start; 

    // Variable to store the count 
    int count = 0; 

    // Iterate the list and 
    // increment the count 
    while (temp.next != start) 
    { 
        temp = temp.next; 
        count++; 
    } 

    // As the list is circular, increment 
    // the counter at last 
    count++; 

    return count; 
} 

// Function to insert a node at 
// a given position in the 
// circular doubly linked list 
static node insertAtLocation( node start, 
                        int data, int loc) 
{ 
    // Declare two pointers 
    node temp, newNode; 
    int i, count; 

    // Create a new node in memory 
    newNode = getNode(); 

    // Point temp to start 
    temp = start; 

    // count of total elements in the list 
    count = countList(start); 

    // If list is empty or the position is 
    // not valid, return false 
    if (temp == null || count < loc) 
        return start; 

    else
    { 
        // Assign the data 
        newNode.data = data; 

        // Iterate till the loc 
        for (i = 1; i < loc - 1; i++) 
        { 
            temp = temp.next; 
        } 

        // See in Image, circle 1 
        newNode.next = temp.next; 

        // See in Image, Circle 2 
        (temp.next).prev = newNode; 

        // See in Image, Circle 3 
        temp.next = newNode; 

        // See in Image, Circle 4 
        newNode.prev = temp; 

        return start; 
    } 

} 

// Function to create circular doubly 
// linked list from array elements 
static node createList(int []arr, int n, node start) 
{ 
    // Declare newNode and temporary pointer 
    node newNode, temp; 
    int i; 

    // Iterate the loop until array length 
    for (i = 0; i < n; i++) 
    { 
        // Create new node 
        newNode = getNode(); 

        // Assign the array data 
        newNode.data = arr[i]; 

        // If it is first element 
        // Put that node prev and next as start 
        // as it is circular 
        if (i == 0) 
        { 
            start = newNode; 
            newNode.prev = start; 
            newNode.next = start; 
        } 

        else
        { 
            // Find the last node 
            temp = (start).prev; 

            // Add the last node to make them 
            // in circular fashion 
            temp.next = newNode; 
            newNode.next = start; 
            newNode.prev = temp; 
            temp = start; 
            temp.prev = newNode; 
        } 
    } 
    return start; 
} 

// Driver Code 
public static void Main() 
{ 
    // Array elements to create 
    // circular doubly linked list 
    int []arr = { 1, 2, 3, 4, 5, 6 }; 
    int n = arr.Length; 

    // Start Pointer 
    node start = null; 

    // Create the List 
    start = createList(arr, n, start); 

    // Display the list before insertion 
    displayList(start); 

    // Inserting 8 at 3rd position 
    start = insertAtLocation(start, 8, 3); 

    // Display the list after insertion 
    displayList(start); 
} 
} 

/* This code contributed by PrinciRaj1992 */

using System;

// Doubly linked list node
public class Node {
    public int data;
    public Node next;
    public Node prev;
}

public class CircularDoublyLinkedList {
    // Function to create a new node
    public static Node GetNode(int data)
    {
        Node newNode = new Node{ data = data, prev = null,
                                 next = null };
        return newNode;
    }

    // Function to display the list
    public static void DisplayList(Node start)
    {
        if (start == null) {
            Console.WriteLine("The list is empty.");
            return;
        }

        Console.Write("The list is: ");
        Node temp = start;

        do {
            Console.Write(temp.data + " ");
            temp = temp.next;
        } while (temp != start);

        Console.WriteLine();
    }

    // Function to count the number of elements in the list
    public static int CountList(Node start)
    {
        if (start == null)
            return 0;

        int count = 0;
        Node temp = start;

        do {
            count++;
            temp = temp.next;
        } while (temp != start);

        return count;
    }

    // Function to insert a node at a given position
    public static bool InsertAtLocation(ref Node start,
                                        int data, int loc)
    {
        int count = CountList(start);

        if (loc < 1 || loc > count + 1)
            return false;

        Node newNode = GetNode(data);

        // If the list is empty
        if (start == null) {
            start = newNode;
            newNode.next = newNode;
            newNode.prev = newNode;
        }
        // If the node is to be inserted at the beginning
        else if (loc == 1) {
            newNode.next = start;
            newNode.prev = start.prev;
            start.prev.next = newNode;
            start.prev = newNode;
            start = newNode;
        }
        else {
            Node temp = start;
            int currPos = 1;

            // Traverse to the node before the desired
            // position
            while (currPos < loc - 1) {
                temp = temp.next;
                currPos++;
            }

            // Insert the new node
            newNode.next = temp.next;
            newNode.prev = temp;
            temp.next.prev = newNode;
            temp.next = newNode;
        }

        return true;
    }

    // Driver Code
    public static void Main()
    {
        // Array elements to create
        // circular doubly linked list
        int[] arr = { 1, 2, 3, 4, 5, 6 };
        int n = arr.Length;

        // Start Pointer
        Node start = null;

        // Create the List
        for (int i = 0; i < n; i++)
            InsertAtLocation(ref start, arr[i], i + 1);

        // Display the list before insertion
        DisplayList(start);

        // Inserting 8 at 3rd position
        InsertAtLocation(ref start, 8, 3);

        // Display the list after insertion
        DisplayList(start);
    }
}