Rotate Doubly linked list by N nodes

Last Updated : 11 Jan, 2023

Given a doubly-linked list, rotate the linked list counter-clockwise by N nodes. Here N is a given positive integer and is smaller than the count of nodes in linked list.

N = 2
Rotated List:

Examples:

Input : a  b  c  d  e   N = 2
Output : c  d  e  a  b 

Input : a  b  c  d  e  f  g  h   N = 4
Output : e  f  g  h  a  b  c  d

Asked in Amazon

Solution 1:

C++

#include<iostream> 
using namespace std; 
  
class Node 
{ 
    public: 
        char data; 
        Node* next; 
        Node* pre; 
    Node(int data) 
    { 
        this->data=data; 
        pre=NULL; 
        next=NULL; 
    } 
}; 
  
void insertAtHead(Node* &head, int data) 
{ 
    Node* n = new Node(data); 
    if(head==NULL) 
    { 
        head=n; 
        return; 
    } 
    n->next=head; 
    head->pre=n; 
    head=n; 
    return; 
} 
void insertAtTail(Node* &head, int data) 
{ 
    if(head==NULL) 
    { 
        insertAtHead(head,data); 
        return; 
    } 
    Node* temp=head; 
    while(temp->next!=NULL) 
    { 
        temp=temp->next; 
    } 
    Node* n=new Node(data); 
    temp->next=n; 
    n->pre=temp; 
    return; 
} 
void display(Node* head) 
{ 
    while(head!=NULL) 
    { 
        cout << head->data << " "; 
        head=head->next; 
    } 
} 
  
void rotateByN(Node* &head, int pos) 
{ 
    // return without any changes if position is 0. 
    if(pos==0) return; 
  
    // Finding last node. 
    Node* temp=head; 
    while(temp->next!=NULL) 
    { 
        temp=temp->next; 
    } 
    // making the list circular. 
    temp->next=head; 
    head->pre=temp; 
  
    // move head and temp by the given position. 
    int count=1; 
    while(count<=pos) 
    { 
        head=head->next; 
        temp=temp->next; 
        count++; 
    } 
  
    // now again make list un-circular. 
    temp->next=NULL; 
    head->pre=NULL; 
} 
int main() 
{ 
    Node* head=NULL; 
    insertAtTail(head,'a'); 
    insertAtTail(head,'b'); 
    insertAtTail(head,'c'); 
    insertAtTail(head,'d'); 
    insertAtTail(head,'e'); 
  
    int n=2; 
    cout << "Given linked list \n"; 
    display(head); 
    rotateByN(head,n); 
    cout << "\nRotated Linked list \n"; 
    display(head); 
    cout << "\n\n"; 
  
    return 0; 
} 

Java

// Java program to rotate a Doubly linked 
// list counter clock wise by N times 
import java.io.*; 
import java.util.*; 
  
class GfG { 
  
    /* Link list node */
    static class Node { 
        char data; 
        Node prev; 
        Node next; 
    } 
    static Node head = null; 
  
    // This function rotates a doubly linked 
    // list counter-clockwise and updates the 
    // head. The function assumes that N is 
    // smallerthan size of linked list. It 
    // doesn't modify the list if N is greater 
    // than or equal to size 
    static void rotate(int N) 
    { 
        if (N == 0) 
            return; 
  
        // Let us understand the below code 
        // for example N = 2 and 
        // list = a <-> b <-> c <-> d <-> e. 
        Node current = head; 
  
        // current will either point to Nth 
        // or NULL after this loop. Current 
        // will point to node 'b' in the 
        // above example 
        int count = 1; 
        while (count < N && current != null) { 
            current = current.next; 
            count++; 
        } 
  
        // If current is NULL, N is greater 
        // than or equal to count of nodes 
        // in linked list. Don't change the 
        // list in this case 
        if (current == null) 
            return; 
  
        // current points to Nth node. Store 
        // it in a variable. NthNode points to 
        // node 'b' in the above example 
        Node NthNode = current; 
  
        // current will point to last node 
        // after this loop current will point 
        // to node 'e' in the above example 
        while (current.next != null) 
            current = current.next; 
  
        // Change next of last node to previous 
        // head. Next of 'e' is now changed to 
        // node 'a' 
        current.next = head; 
  
        // Change prev of Head node to current 
        // Prev of 'a' is now changed to node 'e' 
        (head).prev = current; 
  
        // Change head to (N+1)th node 
        // head is now changed to node 'c' 
        head = NthNode.next; 
  
        // Change prev of New Head node to NULL 
        // Because Prev of Head Node in Doubly 
        // linked list is NULL 
        (head).prev = null; 
  
        // change next of Nth node to NULL 
        // next of 'b' is now NULL 
        NthNode.next = null; 
    } 
  
    // Function to insert a node at the 
    // beginning of the Doubly Linked List 
    static void push(char new_data) 
    { 
        Node new_node = new Node(); 
        new_node.data = new_data; 
        new_node.prev = null; 
        new_node.next = (head); 
        if ((head) != null) 
            (head).prev = new_node; 
        head = new_node; 
    } 
  
    /* Function to print linked list */
    static void printList(Node node) 
    { 
        while (node != null && node.next != null) { 
            System.out.print(node.data + " "); 
            node = node.next; 
        } 
        if (node != null) 
            System.out.print(node.data); 
    } 
  
    // Driver's Code 
    public static void main(String[] args) 
    { 
        /* Start with the empty list */
        // Node head = null; 
  
        /* Let us create the doubly 
        linked list a<->b<->c<->d<->e */
        push('e'); 
        push('d'); 
        push('c'); 
        push('b'); 
        push('a'); 
  
        int N = 2; 
  
        System.out.println("Given linked list "); 
        printList(head); 
        rotate(N); 
        System.out.println(); 
        System.out.println("Rotated Linked list "); 
        printList(head); 
    } 
} 
  
// This code is contributed by Prerna Saini

Python3

# Node of a doubly linked list  
class Node:  
    def __init__(self, next = None,  
                       prev = None, data = None):  
        self.next = next # reference to next node in DLL  
        self.prev = prev # reference to previous node in DLL  
        self.data = data  
  
def push(head, new_data):  
  
    new_node = Node(data = new_data)  
  
    new_node.next = head  
    new_node.prev = None
  
    if head is not None:  
        head.prev = new_node  
  
    head = new_node 
    return head 
  
def printList(head): 
  
    node = head 
  
    print("Given linked list") 
    while(node is not None):  
        print(node.data, end = " "),  
        last = node  
        node = node.next
      
def rotate(start, N): 
    if N == 0 : 
        return
  
    # Let us understand the below code  
    # for example N = 2 and  
    # list = a <-> b <-> c <-> d <-> e.  
    current = start  
  
    # current will either point to Nth  
    # or None after this loop. Current  
    # will point to node 'b' in the  
    # above example  
    count = 1
    while count < N and current != None : 
        current = current.next
        count += 1
  
    # If current is None, N is greater  
    # than or equal to count of nodes  
    # in linked list. Don't change the  
    # list in this case  
    if current == None : 
        return
  
    # current points to Nth node. Store  
    # it in a variable. NthNode points to  
    # node 'b' in the above example  
    NthNode = current  
  
    # current will point to last node  
    # after this loop current will point  
    # to node 'e' in the above example  
    while current.next != None : 
        current = current.next
  
    # Change next of last node to previous  
    # head. Next of 'e' is now changed to  
    # node 'a'  
    current.next = start  
  
    # Change prev of Head node to current  
    # Prev of 'a' is now changed to node 'e'  
    start.prev = current  
  
    # Change head to (N+1)th node  
    # head is now changed to node 'c'  
    start = NthNode.next
  
    # Change prev of New Head node to None  
    # Because Prev of Head Node in Doubly  
    # linked list is None  
    start.prev = None
  
    # change next of Nth node to None  
    # next of 'b' is now None  
    NthNode.next = None
  
    return start 
  
# Driver Code 
if __name__ == "__main__": 
    head = None
  
    head = push(head, 'e') 
    head = push(head, 'd') 
    head = push(head, 'c') 
    head = push(head, 'b') 
    head = push(head, 'a') 
  
    printList(head) 
    print("\n") 
      
    N = 2
    head = rotate(head, N) 
  
    printList(head) 
  
# This code is contributed by vinayak sharma 

C#

// C# program to rotate a Doubly linked  
// list counter clock wise by N times  
using System; 
  
class GfG  
{  
  
/* Link list node */
public class Node  
{  
    public char data;  
    public Node prev;  
    public Node next;  
}  
static Node head = null;  
  
// This function rotates a doubly linked  
// list counter-clockwise and updates the  
// head. The function assumes that N is  
// smallerthan size of linked list. It  
// doesn't modify the list if N is greater  
// than or equal to size  
static void rotate( int N)  
{  
    if (N == 0)  
        return;  
  
    // Let us understand the below code  
    // for example N = 2 and  
    // list = a <-> b <-> c <-> d <-> e.  
    Node current = head;  
  
    // current will either point to Nth  
    // or NULL after this loop. Current  
    // will point to node 'b' in the  
    // above example  
    int count = 1;  
    while (count < N && current != null)  
    {  
        current = current.next;  
        count++;  
    }  
  
    // If current is NULL, N is greater  
    // than or equal to count of nodes  
    // in linked list. Don't change the  
    // list in this case  
    if (current == null)  
        return;  
  
    // current points to Nth node. Store  
    // it in a variable. NthNode points to  
    // node 'b' in the above example  
    Node NthNode = current;  
  
    // current will point to last node  
    // after this loop current will point  
    // to node 'e' in the above example  
    while (current.next != null)  
        current = current.next;  
  
    // Change next of last node to previous  
    // head. Next of 'e' is now changed to  
    // node 'a'  
    current.next = head;  
  
    // Change prev of Head node to current  
    // Prev of 'a' is now changed to node 'e'  
    (head).prev = current;  
  
    // Change head to (N+1)th node  
    // head is now changed to node 'c'  
    head = NthNode.next;  
  
    // Change prev of New Head node to NULL  
    // Because Prev of Head Node in Doubly  
    // linked list is NULL  
    (head).prev = null;  
  
    // change next of Nth node to NULL  
    // next of 'b' is now NULL  
    NthNode.next = null;  
}  
  
// Function to insert a node at the  
// beginning of the Doubly Linked List  
static void push(char new_data)  
{  
    Node new_node = new Node();  
    new_node.data = new_data;  
    new_node.prev = null;  
    new_node.next = (head);  
    if ((head) != null)  
        (head).prev = new_node;  
    head = new_node;  
}  
  
/* Function to print linked list */
static void printList(Node node)  
{  
    while (node != null && node.next != null)  
    {  
        Console.Write(node.data + " ");  
        node = node.next;  
    }  
    if(node != null)  
    Console.Write(node.data);  
}  
  
// Driver Code  
public static void Main(String []args)  
{  
    /* Start with the empty list */
    // Node head = null;  
  
    /* Let us create the doubly  
    linked list a<->b<->c<->d<->e */
    push( 'e');  
    push( 'd');  
    push( 'c');  
    push( 'b');  
    push( 'a');  
  
    int N = 2;  
  
    Console.WriteLine("Given linked list ");  
    printList(head);  
    rotate( N);  
    Console.WriteLine();  
    Console.WriteLine("Rotated Linked list ");  
    printList(head);  
}  
}  
  
// This code is contributed by Arnab Kundu 

Javascript

<script> 
// javascript program to rotate a Doubly linked  
// list counter clock wise by N times  
  
    /* Link list node */
     class Node { 
            constructor() { 
                this.data = 0; 
                this.prev = null; 
                this.next = null; 
            } 
        } 
    var head = null; 
  
    // This function rotates a doubly linked 
    // list counter-clockwise and updates the 
    // head. The function assumes that N is 
    // smallerthan size of linked list. It 
    // doesn't modify the list if N is greater 
    // than or equal to size 
    function rotate(N) { 
        if (N == 0) 
            return; 
  
        // Let us understand the below code 
        // for example N = 2 and 
        // list = a <-> b <-> c <-> d <-> e. 
var current = head; 
  
        // current will either point to Nth 
        // or NULL after this loop. Current 
        // will point to node 'b' in the 
        // above example 
        var count = 1; 
        while (count < N && current != null) { 
            current = current.next; 
            count++; 
        } 
  
        // If current is NULL, N is greater 
        // than or equal to count of nodes 
        // in linked list. Don't change the 
        // list in this case 
        if (current == null) 
            return; 
  
        // current points to Nth node. Store 
        // it in a variable. NthNode points to 
        // node 'b' in the above example 
var NthNode = current; 
  
        // current will point to last node 
        // after this loop current will point 
        // to node 'e' in the above example 
        while (current.next != null) 
            current = current.next; 
  
        // Change next of last node to previous 
        // head. Next of 'e' is now changed to 
        // node 'a' 
        current.next = head; 
  
        // Change prev of Head node to current 
        // Prev of 'a' is now changed to node 'e' 
        (head).prev = current; 
  
        // Change head to (N+1)th node 
        // head is now changed to node 'c' 
        head = NthNode.next; 
  
        // Change prev of New Head node to NULL 
        // Because Prev of Head Node in Doubly 
        // linked list is NULL 
        (head).prev = null; 
  
        // change next of Nth node to NULL 
        // next of 'b' is now NULL 
        NthNode.next = null; 
    } 
  
    // Function to insert a node at the 
    // beginning of the Doubly Linked List 
    function push( new_data) { 
var new_node = new Node(); 
        new_node.data = new_data; 
        new_node.prev = null; 
        new_node.next = (head); 
        if ((head) != null) 
            (head).prev = new_node; 
        head = new_node; 
    } 
  
    /* Function to print linked list */
    function printList(node) { 
        while (node != null && node.next != null) { 
            document.write(node.data + " "); 
            node = node.next; 
        } 
        if (node != null) 
            document.write(node.data); 
    } 
  
    // Driver's Code 
      
        /* Start with the empty list */
        // Node head = null; 
  
        /* 
         * Let us create the doubly linked list a<->b<->c<->d<->e 
         */
        push('e'); 
        push('d'); 
        push('c'); 
        push('b'); 
        push('a'); 
  
        var N = 2; 
  
        document.write("Given linked list <br/>"); 
        printList(head); 
        rotate(N); 
        document.write(); 
        document.write("<br/>Rotated Linked list <br/>"); 
        printList(head); 
  
// This code contributed by aashish1995 
</script> 

Output

Before Rotation : 
a-->b-->c-->d-->e-->NULL

After Rotation : 
c-->d-->e-->a-->b-->NULL

Time Complexity: O(N)
Space Complexity: O(1)

Solution 2:

C++

#include<iostream> 
using namespace std; 
  
class Node 
{ 
    public: 
        char data; 
        Node* next; 
        Node* pre; 
    Node(int data) 
    { 
        this->data=data; 
        pre=NULL; 
        next=NULL; 
    } 
}; 
  
void insertAtHead(Node* &head, int data) 
{ 
    Node* n = new Node(data); 
    if(head==NULL) 
    { 
        head=n; 
        return; 
    } 
    n->next=head; 
    head->pre=n; 
    head=n; 
    return; 
} 
void insertAtTail(Node* &head, int data) 
{ 
    if(head==NULL) 
    { 
        insertAtHead(head,data); 
        return; 
    } 
    Node* temp=head; 
    while(temp->next!=NULL) 
    { 
        temp=temp->next; 
    } 
    Node* n=new Node(data); 
    temp->next=n; 
    n->pre=temp; 
    return; 
} 
void display(Node* head) 
{ 
    while(head!=NULL) 
    { 
        cout << head->data << "-->"; 
        head=head->next; 
    } 
    cout << "NULL\n"; 
} 
  
void rotateByN(Node *&head, int pos) 
{ 
    if (pos == 0) 
        return; 
  
    Node *curr = head; 
  
    while (pos) 
    { 
        curr = curr->next; 
        pos--; 
    } 
  
    Node *tail = curr->pre; 
    Node *NewHead = curr; 
    tail->next = NULL; 
    curr->pre = NULL; 
  
    while (curr->next != NULL) 
    { 
        curr = curr->next; 
    } 
      
    curr->next = head; 
    head->pre = curr; 
    head = NewHead; 
} 
   
int main() 
{ 
    Node* head=NULL; 
    insertAtTail(head,'a'); 
    insertAtTail(head,'b'); 
    insertAtTail(head,'c'); 
    insertAtTail(head,'d'); 
    insertAtTail(head,'e'); 
  
    int n=2; 
    cout << "\nBefore Rotation : \n"; 
    display(head); 
    rotateByN(head,n); 
    cout << "\nAfter Rotation : \n"; 
    display(head); 
    cout << "\n\n"; 
  
    return 0; 
}

Java

// Java code to rotate doubly linked list by N nodes. 
import java.util.*; 
import java.io.*; 
  
class GFG { 
  
    class Node { 
        char data; 
        Node next; 
        Node pre; 
        Node(char data) 
        { 
            this.data = data; 
            pre = null; 
            next = null; 
        } 
    } 
  
    Node head = null; 
  
    // Function to insert nodes at the start of the linked 
    // list. 
    public void insertAtHead(char data) 
    { 
        Node n = new Node(data); 
        if (head == null) { 
            head = n; 
            return; 
        } 
        n.next = head; 
        head.pre = n; 
        head = n; 
    } 
  
    // Function to insert nodes at the tail of the linked 
    // list. 
    public void insertAtTail(char data) 
    { 
        if (head == null) { 
            insertAtHead(data); 
            return; 
        } 
        Node temp = head; 
        while (temp.next != null) { 
            temp = temp.next; 
        } 
        Node n = new Node(data); 
        temp.next = n; 
        n.pre = temp; 
    } 
  
    // Function to print the list. 
    public void display() 
    { 
        Node curr = head; 
        while (curr != null) { 
            System.out.print(curr.data + "-->"); 
            curr = curr.next; 
        } 
        System.out.print("NULL\n\n"); 
    } 
  
    // Function to rotate doubly linked list by N nodes. 
    public void rotateByN(int pos) 
    { 
        if (pos == 0) { 
            return; 
        } 
        Node curr = head; 
        while (pos != 0) { 
            curr = curr.next; 
            pos--; 
        } 
        Node tail = curr.pre; 
        Node NewHead = curr; 
        tail.next = null; 
        curr.pre = null; 
        while (curr.next != null) { 
            curr = curr.next; 
        } 
        curr.next = head; 
        head.pre = curr; 
        head = NewHead; 
    } 
  
    public static void main(String[] args) 
    { 
        GFG list = new GFG(); 
  
        list.insertAtTail('a'); 
        list.insertAtTail('b'); 
        list.insertAtTail('c'); 
        list.insertAtTail('d'); 
        list.insertAtTail('e'); 
  
        int n = 2; 
        System.out.print("Before Rotation : \n"); 
        list.display(); 
        
        list.rotateByN(n); 
        System.out.print("After Rotation : \n"); 
        list.display(); 
    } 
} 
  
// This code is contributed by lokesh (lokeshmvs21).

Python3

# Python code to rotate doubly linked list by N nodes. 
class Node: 
    def __init__(self, data): 
        self.data = data 
        self.pre = None
        self.next = None
  
class GFG: 
    def __init__(self): 
        self.head = None
  
    # Function to insert nodes at the start of the linked list. 
    def insertAtHead(self, data): 
        n = Node(data) 
        if self.head == None: 
            self.head = n 
            return
  
        n.next = self.head 
        self.head.pre = n 
        self.head = n 
        return
  
    # Function to insert nodes at the tail of the linked list. 
    def insertAtTail(self, data): 
        if self.head == None: 
            self.insertAtHead(data) 
            return
        temp = self.head 
        while temp.next != None: 
            temp = temp.next
        n = Node(data) 
        temp.next = n 
        n.pre = temp 
        return
        
    # Function to print the list. 
    def display(self): 
        temp = self.head 
        while temp != None: 
            print(temp.data, "-->", sep="", end="") 
            temp = temp.next
        print("NULL") 
  
    # Function to rotate doubly linked list by N nodes. 
    def rotateByN(self, pos): 
        if pos == 0: 
            return
        curr = self.head 
        while pos: 
            curr = curr.next
            pos -= 1
        tail = curr.pre 
        NewHead = curr 
        tail.next = None
        curr.pre = None
  
        while curr.next != None: 
            curr = curr.next
  
        curr.next = self.head 
        self.head.pre = curr 
        self.head = NewHead 
  
  
# Driver Code 
if __name__ == "__main__": 
    list = GFG() 
    list.insertAtTail('a') 
    list.insertAtTail('b') 
    list.insertAtTail('c') 
    list.insertAtTail('d') 
    list.insertAtTail('e') 
  
    n = 2
    print("Before Rotation : ") 
    list.display() 
    list.rotateByN(n) 
    print("\nAfter Rotation : ") 
    list.display() 
    print() 
  
# This code is contributed by Tapesh(tapeshdua420) 

C#

// C# code to rotate doubly linked list by N nodes. 
  
using System; 
  
public class GFG { 
  
    class Node { 
        public char data; 
        public Node next, pre; 
        public Node(char data) 
        { 
            this.data = data; 
            pre = null; 
            next = null; 
        } 
    } 
  
    Node head = null; 
  
    // Function to insert nodes at the start of the linked 
    // list. 
    public void insertAtHead(char data) 
    { 
        Node n = new Node(data); 
        if (head == null) { 
            head = n; 
            return; 
        } 
        n.next = head; 
        head.pre = n; 
        head = n; 
    } 
  
    // Function to insert nodes at the tail of the linked 
    // list. 
    public void insertAtTail(char data) 
    { 
        if (head == null) { 
            insertAtHead(data); 
            return; 
        } 
        Node temp = head; 
        while (temp.next != null) { 
            temp = temp.next; 
        } 
        Node n = new Node(data); 
        temp.next = n; 
        n.pre = temp; 
    } 
  
    // Function to print the list. 
    public void display() 
    { 
        Node curr = head; 
        while (curr != null) { 
            Console.Write(curr.data + "-->"); 
            curr = curr.next; 
        } 
        Console.Write("NULL\n\n"); 
    } 
  
    // Function to rotate doubly linked list by N nodes. 
    public void rotateByN(int pos) 
    { 
        if (pos == 0) { 
            return; 
        } 
        Node curr = head; 
        while (pos != 0) { 
            curr = curr.next; 
            pos--; 
        } 
        Node tail = curr.pre; 
        Node NewHead = curr; 
        tail.next = null; 
        curr.pre = null; 
        while (curr.next != null) { 
            curr = curr.next; 
        } 
        curr.next = head; 
        head.pre = curr; 
        head = NewHead; 
    } 
  
    static public void Main() 
    { 
  
        // Code 
        GFG list = new GFG(); 
  
        list.insertAtTail('a'); 
        list.insertAtTail('b'); 
        list.insertAtTail('c'); 
        list.insertAtTail('d'); 
        list.insertAtTail('e'); 
  
        int n = 2; 
        Console.Write("Before Rotation : \n"); 
        list.display(); 
  
        list.rotateByN(n); 
        Console.Write("After Rotation : \n"); 
        list.display(); 
    } 
} 
  
// This code is contributed by lokesh(lokeshmvs21).

Javascript

<script> 
// Javascript code to Rotate Doubly linked list by N nodes 
  
let head = null; 
  
  
class Node { 
    constructor(data) { 
        this.data = data; 
        this.pre = null; 
        this.next = null; 
    } 
}; 
  
function insertAtHead(data) { 
    let n = new Node(data); 
    if (head == null) { 
        head = n; 
        return; 
    } 
    n.next = head; 
    head.pre = n; 
    head = n; 
    return; 
} 
  
function insertAtTail(data) { 
    if (head == null) { 
        insertAtHead(data); 
        return; 
    } 
    let temp = head; 
    while (temp.next != null) { 
        temp = temp.next; 
    } 
    let n = new Node(data); 
    temp.next = n; 
    n.pre = temp; 
    return; 
} 
  
function display(head) { 
    while (head != null) { 
        document.write(head.data + "-->"); 
        head = head.next; 
    } 
    document.write("null<br>"); 
} 
  
function rotateByN(pos) { 
    if (pos == 0) 
        return; 
  
    let curr = head; 
  
    while (pos) { 
        curr = curr.next; 
        pos--; 
    } 
  
    let tail = curr.pre; 
    let NewHead = curr; 
    tail.next = null; 
    curr.pre = null; 
  
    while (curr.next != null) { 
        curr = curr.next; 
    } 
  
    curr.next = head; 
    head.pre = curr; 
    head = NewHead; 
} 
  
insertAtTail('a'); 
insertAtTail('b'); 
insertAtTail('c'); 
insertAtTail('d'); 
insertAtTail('e'); 
  
let n = 2; 
document.write("<br>Before Rotation : <br>"); 
display(head); 
rotateByN(head, n); 
document.write("<br>After Rotation : <br>"); 
display(head); 
document.write("<br><br>"); 
</script>

Output

Before Rotation : 
a-->b-->c-->d-->e-->NULL

After Rotation : 
c-->d-->e-->a-->b-->NULL

Time Complexity: O(N)
Space Complexity: O(1)

Suggest improvement

Rotate the sub-list of a linked list from position M to N to the right by K places

Undulating numbers

Share your thoughts in the comments

Rotate Doubly linked list by N nodes

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?