Sort the Bitonic Doubly Linked List Using Constant Space

// C# implementation to sort the
// biotonic doubly linked list

class Node {
    public int data;
    public Node next;
    public Node prev;

    public Node(int x) {
        data = x;
        next = null;
        prev = null;
    }
}

class GfG {
  
    // Function to reverse a Doubly Linked List
    static Node Reverse(Node headRef) {
        Node temp = null;
        Node currNode = headRef;

        // Swap next and prev for all nodes of 
      	// doubly linked list
        while (currNode != null) {
            temp = currNode.prev;
            currNode.prev = currNode.next;
            currNode.next = temp;
            currNode = currNode.prev;
        }

        // Before changing head, check for the cases like 
      	// empty list and list with only one node
        if (temp != null)
            headRef = temp.prev;

        return headRef;
    }

    // Function to merge two sorted doubly linked lists
    static Node Merge(Node first, Node second) {
      
        // If first linked list is empty
        if (first == null)
            return second;

        // If second linked list is empty
        if (second == null)
            return first;

        // Create a dummy node to act as the head
      	// of the merged list
        Node dummy = new Node(0);
        Node tail = dummy;

        while (first != null && second != null) {
          
            // Pick the smaller value
            if (first.data < second.data) {
                tail.next = first;
                first.prev = tail;
                first = first.next;
            }
            else {
              
                tail.next = second;
                second.prev = tail;
                second = second.next;
            }
            tail = tail.next;
        }

        // Append the remaining nodes of the
     	// non-empty list
        if (first != null) {
            tail.next = first;
            first.prev = tail;
        }
        else {
            tail.next = second;
            second.prev = tail;
        }

        // Adjust the head of the merged list
        Node mergedHead = dummy.next;
        mergedHead.prev = null;

        return mergedHead;
    }


    // Function to sort a bitonic doubly linked list
    static Node Sort(Node head) {
      
        // If list is empty or if it contains a 
      	// single node only
        if (head == null || head.next == null)
            return head;

        Node currNode = head.next;

        while (currNode != null) {
          
            // If true, then 'currNode' is the first node
          	// which is smaller than its previous node
            if (currNode.data < currNode.prev.data)
                break;

            // Move to the next node
            currNode = currNode.next;
        }

        // If true, then list is already sorted
        if (currNode == null)
            return head;

        // Split into two lists, one starting with 
      	// 'head' and the other starting with 'currNode'
        currNode.prev.next = null;
        currNode.prev = null;

        // Reverse the list starting with 'currNode'
        currNode = Reverse(currNode);

        // Merge the two lists and return the 
      	// final merged doubly linked list
        return Merge(head, currNode);
    }

    static void PrintList(Node head) {

        while (head != null) {
            System.Console.Write(head.data + " ");
            head = head.next;
        }
        System.Console.WriteLine();
    }

    static void Main(string[] args) {
      
        // Create the doubly linked list:
    	// 2<->12<->11<->1
        Node head = new Node(2);
        head.next = new Node(12);
        head.next.prev = head;
        head.next.next = new Node(11);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(1);
        head.next.next.next.prev = head.next.next;
      
        head = Sort(head);
        PrintList(head);
    }
}