Swap Kth node from beginning with Kth node from end in a Doubly Linked List

// C# implementation of the approach
using System;
public class GFG {
 
    // Doubly Linked List implementation
    private class Node {
        private int data;
        private Node next;
        private Node previous;
 
        public Node(int data, Node next,
                    Node previous)
        {
            this.data = data;
            this.next = next;
            this.previous = previous;
        }
 
        public int getData()
        {
            return data;
        }
 
        public void setData(int data)
        {
            this.data = data;
        }
 
        public Node getNext()
        {
            return next;
        }
 
        public void setNext(Node next)
        {
            this.next = next;
        }
 
        public Node getPrevious()
        {
            return previous;
        }
 
        public void setPrevious(Node previous)
        {
            this.previous = previous;
        }
    }
 
    private Node head;
    private Node tail;
 
    public GFG()
    {
        this.head = null;
        this.tail = null;
    }
 
    Node getHead()
    {
        return head;
    }
 
    void setHead(Node head)
    {
        this.head = head;
    }
 
    Node getTail()
    {
        return tail;
    }
 
    void setTail(Node tail)
    {
        this.tail = tail;
    }
 
    // Function to replace Kth node from
    // beginning with Kth node from end
    void swapNode(Node headReference,
                         Node tailReference, int k)
    {
 
        // If K is 1, then the first node
        // has to be swapped with the
        // last node in the doubly linked list
        if (k == 1) {
            swapFirstAndLast(headReference,
                             tailReference);
            return;
        }
 
        // If k is N, then the last node
        // has to be swapped with the
        // first node in the doubly linked list
        int nodeCount = getCount(headReference);
        if (k == nodeCount) {
            swapFirstAndLast(headReference,
                             tailReference);
            return;
        }
 
        // If the K<sup>th</sup> node from
        // the beginning and K<sup>th</sup> node
        // from the ending are same
        if (2 * k - 1 == nodeCount) {
            return;
        }
 
        // fNode represents K<sup>th</sup> node
        // from the beginning
        Node fNode = headReference;
        for (int i = 1; i < k; i++) {
            fNode = fNode.getNext();
        }
        Node fNodePrevious = fNode.getPrevious();
        Node fNodeNext = fNode.getNext();
 
        // sNode represents K<sup>th</sup> node
        // from the ending
        Node sNode = tailReference;
        for (int i = 1; i < k; i++) {
            sNode = sNode.getPrevious();
        }
 
        Node sNodePrevious = sNode.getPrevious();
        Node sNodeNext = sNode.getNext();
 
        // Checking if any of the pointers is null
        // and interchanging the pointers
        if (fNodePrevious != null && sNode != null) {
 
            fNodePrevious.setNext(sNode);
            sNode.setPrevious(fNodePrevious);
            sNode.setNext(fNodeNext);
            fNodeNext.setPrevious(sNode);
        }
        if (sNodePrevious != null && sNodeNext != null) {
 
            sNodeNext.setPrevious(fNode);
            fNode.setNext(sNodeNext);
            sNodePrevious.setNext(fNode);
            fNode.setPrevious(sNodePrevious);
        }
    }
 
    // Function to swap the first and
    // last node in the doubly linked list
    private void swapFirstAndLast(
        Node headReference,
        Node tailReference)
    {
        Node headRef = headReference;
        Node tailRef = tailReference;
 
        headReference
            = headReference.getNext();
        tailReference
            = tailReference.getPrevious();
 
        tailReference.setNext(headRef);
        headRef.setPrevious(tailReference);
        headRef.setNext(null);
        this.setTail(tailReference.getNext());
 
        headReference.setPrevious(tailRef);
        tailRef.setNext(headReference);
        tailRef.setPrevious(null);
        this.setHead(headReference
                         .getPrevious());
    }
 
    // Function to return the number of nodes
    // in the linked list
    private int getCount(Node headReference)
    {
        int nodeCount = 0;
        while (headReference != null) {
            nodeCount++;
            headReference = headReference
                                .getNext();
        }
        return nodeCount;
    }
 
    // Function to print the Linked List
    void printList(Node headReference)
    {
        if (headReference == null) {
            Console.WriteLine(
                "Doubly linked list is empty");
            return;
        }
        else {
            while (headReference != null) {
                Console.Write(
                    headReference.getData()
                    + " ");
                headReference
                    = headReference.getNext();
            }
        }
    }
 
    // Function to insert a node at
    // the end of the doubly linked list
    void Push(int data)
    {
        Node newNode
            = new Node(data, null, null);
 
        if (head == null) {
            head = tail = newNode;
        }
        else {
            tail.setNext(newNode);
            newNode.setPrevious(tail);
            tail = newNode;
        }
    }
 
    // Driver code
    public static void Main(String[] args)
    {
 
        // Creating an object for the class
        GFG list = new GFG();
 
        // Adding data to the linked list
        list.Push(1);
        list.Push(2);
        list.Push(3);
        list.Push(4);
        list.Push(5);      
            
        // Calling the function
        int K = 2;
        list.swapNode(list.getHead(),
                      list.getTail(), K);
        list.printList(list.getHead());
    }
}

// This code is contributed by 29AjayKumar

// C# program to swap Kth node from beginning with the Kth
// node from the end without using temporary node and without
// swapping the data
using System;

public class GFG {

    // class Node
    class Node {
        public int data;
        public Node first, next;
        public Node(int data)
        {
            this.data = data;
            first = null;
            next = null;
        }
    }

    // head pointer for pointing to start of the linked list
    // last pointer for pointing to last node of the linked
    // list
    Node head = null, last = null;

    // function for inserting new node at the end of the
    // list using last pointer
    void AddLast(int data)
    {
        Node temp = new Node(data);
        if (head == null) {
            head = temp;
            last = temp;
        }
        else {
            last.next = temp;
            temp.first = last;
            last = temp;
        }
    }

    // function for printing the doubly linked list
    void printList()
    {
        Node p = head;
        while (p != null) {
            Console.Write(p.data + "<->");
            p = p.next;
        }
        Console.Write("null");
        Console.WriteLine();
    }

    // function for swapping Kth node from beginning with
    // Kth node from the end
    void swapKthNodes(int k)
    {
        int count = 1;
        Node p = head, q = last;
        // case 1: to swap the start and end nodes case 1
        // figure
        if (k == 1) {
            q.first.next = p;
            p.first = q.first;

            q.next = p.next;
            p.next.first = q;

            // change these links to null to the break
            // circular link
            p.next = null;
            q.first = null;

            head = q;
            last = p;
        }
        else {
            while (p != null && q != null && count < k) {
                count++;
                p = p.next;
                q = q.first;
            }

            // case 3: if the nodes to be swapped are the
            // middle nodes given in the figure
            if (p.next == q) {
                p.first.next = p.next.next;
                q.next.first = p.first;

                p.next = p.first;
                q.first = q.next = p.first;

                q.next = p;
                p.next.next.first = p;
                p.next = p.first.next;

                p.first.next = q;
                p.first = q;
            }
            // case 2: other than middle nodes given in case
            // 2 figure
            else {
                q.first.next = q.next;
                q.next.first = q.first;
                q.next = q.first;

                p.first.next = p.next;
                p.next.first = p.first;
                p.next = p.first;

                p.first = q.first;
                q.first = p.next;

                p.next = p.first;
                q.next = q.first;

                q.next = q.next.next;
                q.first.next = q;
                q.next.first = q;

                p.next = p.next.next;
                p.first.next = p;
                p.next.first = p;
            }
        }
    }

    static public void Main()
    {

        GFG list = new GFG();

        // function calls for inserting
        // at the end of the list
        list.AddLast(10);
        list.AddLast(20);
        list.AddLast(30);
        list.AddLast(40);
        list.AddLast(50);
        list.AddLast(60);

        Console.WriteLine("Before swapping:");
        // print list before swapping the nodes
        list.printList();
        Console.WriteLine();

        // function call for swapping Kth nodes
        list.swapKthNodes(1);

        Console.WriteLine(
            "After swapping nodes for k = 1:");
        // print list after swapping the nodes
        list.printList();
        Console.WriteLine();

        list.swapKthNodes(2);
        Console.WriteLine(
            "After swapping nodes for k = 2:");
        list.printList();
        Console.WriteLine();

        list.swapKthNodes(3);
        Console.WriteLine(
            "After swapping nodes for k = 3 (middle):");
        list.printList();
        Console.WriteLine();
    }
}

// This code is contributed by lokesh (lokeshmvs21).