Rotate Doubly linked list by N nodes

Last Updated : 11 Jul, 2025

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

Examples:

Input:

Output:

Explanation: After rotating the list by p = 2, the new head will be the node with value 3.

Input:

Output:

Explanation: After rotating the list by p = 3, the new head will be the node with value 4.

Table of Content

[Expected Approach - 1] Making a Circular DLL - O(n) Time and O(1) Space
[Expected Approach - 2] Break at pth node and Link - O(n) Time and O(1) Space

[Expected Approach - 1] Making a Circular DLL - O(n) Time and O(1) Space

The idea is to make the list circular by connecting the tail to the head. Then, we move the head and tail pointers p positions forward, and finally, break the circular link to restore the list’s original structure with the new head and tail. This approach efficiently rotates the list by adjusting the links without rearranging node data.

Follow the steps below to solve the problem:

Link the last node's next pointer to the head and set the head's prev pointer to the tail.
Traverse the list by p positions to shift the head to the new position and adjust the tail accordingly.
Set the new tail’s next pointer to null and the new head’s prev pointer to null.
The new head is now at the desired position after the rotation.

C++

// C++ program to rotate a doubly-linked 
// list counter-clockwise
#include <bits/stdc++.h>
using namespace std;

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

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

// Function to rotate the doubly-linked list
Node* rotateDLL(Node* head, int p) {

    Node* tail = head;

    // Find the last node
    while (tail->next) {
        tail = tail->next;
    }

    // Make the list circular
    tail->next = head;
    head->prev = tail;

    // Move head and tail by the given position
    for (int count = 1; count <= p; count++) {
        head = head->next;
        tail = tail->next;
    }

    // Break the circular connection
    tail->next = nullptr;
    head->prev = nullptr;

    return head;
}

void printList(Node* head) {
    Node* curr = head;
    while (curr) {
        cout << curr->data;
        if (curr->next) cout << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
  
    Node* head = new Node(2);
    head->next = new Node(6);
    head->next->prev = head;
    head->next->next = new Node(5);
    head->next->next->prev = head->next;
    head->next->next->next = new Node(4);
    head->next->next->next->prev = head->next->next;

    int p = 3;
    head = rotateDLL(head, p);
    printList(head);

    return 0;
}

Java

// Java program to rotate a doubly-linked 
// list counter-clockwise by p positions
class Node {
    int data;
    Node prev, next;

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

class GfG {

    // Function to rotate the doubly-linked list
    static Node rotateDLL(Node head, int p) {
        Node tail = head;

        // Find the last node
        while (tail.next != null) {
            tail = tail.next;
        }

        // Make the list circular
        tail.next = head;
        head.prev = tail;

        // Move head and tail by the given position
        for (int count = 1; count <= p; count++) {
            head = head.next;
            tail = tail.next;
        }

        // Break the circular connection
        tail.next = null;
        head.prev = null;

        return head;
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data);
            if (curr.next != null) {
                System.out.print(" ");
            }
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {

        Node head = new Node(2);
        head.next = new Node(6);
        head.next.prev = head;
        head.next.next = new Node(5);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(4);
        head.next.next.next.prev = head.next.next;

        int p = 3;
        head = rotateDLL(head, p);
        printList(head);
    }
}

Python

# Python program to rotate a doubly-linked 
# list counter-clockwise by p positions
class Node:
    def __init__(self, x):
        self.data = x
        self.prev = None
        self.next = None
        
# Function to rotate the doubly-linked list
def rotateDLL(head, p):
    tail = head

    # Find the last node
    while tail.next:
        tail = tail.next

    # Make the list circular
    tail.next = head
    head.prev = tail

    # Move head and tail by the given position
    for i in range(p):
        head = head.next
        tail = tail.next

    # Break the circular connection
    tail.next = None
    head.prev = None

    return head

def printList(head):
    curr = head
    while curr:
        print(curr.data, end="")
        if curr.next:
            print(" ", end="")
        curr = curr.next
    print()

if __name__ == "__main__":
  
    head = Node(2)
    head.next = Node(6)
    head.next.prev = head
    head.next.next = Node(5)
    head.next.next.prev = head.next
    head.next.next.next = Node(4)
    head.next.next.next.prev = head.next.next

    p = 3
    head = rotateDLL(head, p)
    printList(head)

// C# program to rotate a doubly-linked 
// list counter-clockwise
using System;

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

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

class GfG {
  
    // Function to rotate the doubly-linked list
    static Node rotateDLL(Node head, int p) {
     
        Node tail = head;

        // Find the last node
        while (tail.next != null) {
            tail = tail.next;
        }

        // Make the list circular
        tail.next = head;
        head.prev = tail;

        // Move head and tail by the given position
        for (int count = 1; count <= p; count++) {
            head = head.next;
            tail = tail.next;
        }

        // Break the circular connection
        tail.next = null;
        head.prev = null;

        return head;
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data);
            if (curr.next != null)
                Console.Write(" ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main(string[] args) {
      
        Node head = new Node(2);
        head.next = new Node(6);
        head.next.prev = head;
        head.next.next = new Node(5);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(4);
        head.next.next.next.prev = head.next.next;

        int p = 3;
        head = rotateDLL(head, p);
        printList(head);
    }
}

JavaScript

// JavaScript program to rotate a doubly-linked 
// list counter-clockwise by p positions
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

// Function to rotate the doubly-linked list
function rotateDLL(head, p) {
    let tail = head;

    // Find the last node
    while (tail.next !== null) {
        tail = tail.next;
    }

    // Make the list circular
    tail.next = head;
    head.prev = tail;

    // Move head and tail by the given position
    let count = 1;
    while (count <= p) {
        head = head.next;
        tail = tail.next;
        count++;
    }

    // Break the circular connection
    tail.next = null;
    head.prev = null;

    return head;
}

function printList(head) {
    let curr = head;
    while (curr) {
        console.log(curr.data);
        if (curr.next) console.log(" ");
        curr = curr.next;
    }
    console.log();
}

let head = new Node(2);
head.next = new Node(6);
head.next.prev = head;
head.next.next = new Node(5);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;

let p = 3;
head = rotateDLL(head, p);
printList(head);

Output

4 2 6 5

[Expected Approach - 2] Break at p^th node and Link - O(n) Time and O(1) Space

The idea is to first find the p-th node, then adjust the prev and next pointers to disconnect the list, re-link it, and make the new head the node after the p-th node. Finally, we reconnect the list's tail to the original head to maintain continuity.

Follow the steps below to solve the problem:

Move to the node at position p in the list.
Set the next pointer of the p-th node to null and the prev pointer of the next node to null.
Traverse the list from the new head to find the tail node.
Attach the original head node to the tail node and set the tail's next pointer to null.
The new head is now the node after the p-th node.

C++

// C++ program to rotate a doubly-linked 
// list counter-clockwise
#include <bits/stdc++.h>
using namespace std;

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

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

// Function to rotate the doubly-linked list
Node* rotateDLL(Node* head, int p) {

    Node* curr = head;

    // Traverse to the p-th node
    for (int i = 1; i < p; i++) {
        curr = curr->next;
    }

    if (!curr || !curr->next) return head;

    // Update pointers to perform the rotation
    Node* newHead = curr->next;
    newHead->prev = nullptr;
    curr->next = nullptr;

    Node* tail = newHead;
    while (tail->next) {
        tail = tail->next;
    }

    // Connect the old tail to the old head
    tail->next = head;
    head->prev = tail;

    return newHead;
}

void printList(Node* head) {
    Node* curr = head;
    while (curr) {
        cout << curr->data;
        if (curr->next) cout << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
  
    Node* head = new Node(2);
    head->next = new Node(6);
    head->next->prev = head;
    head->next->next = new Node(5);
    head->next->next->prev = head->next;
    head->next->next->next = new Node(4);
    head->next->next->next->prev = head->next->next;

    int p = 3;
    head = rotateDLL(head, p);
    printList(head);

    return 0;
}

Java

// Java program to rotate a doubly-linked 
// list counter-clockwise
class Node {
    int data;
    Node prev, next;

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

class GfG {
    
    // Function to rotate the doubly-linked list
    static Node rotateDLL(Node head, int p) {
   
        Node curr = head;

        // Traverse to the p-th node
        for (int i = 1; i < p; i++) {
            curr = curr.next;
        }

        if (curr == null || curr.next == null) return head;

        // Update pointers to perform the rotation
        Node newHead = curr.next;
        newHead.prev = null;
        curr.next = null;

        Node tail = newHead;
        while (tail.next != null) {
            tail = tail.next;
        }

        // Connect the old tail to the old head
        tail.next = head;
        head.prev = tail;

        return newHead;
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data);
            if (curr.next != null) System.out.print(" ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {

        Node head = new Node(2);
        head.next = new Node(6);
        head.next.prev = head;
        head.next.next = new Node(5);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(4);
        head.next.next.next.prev = head.next.next;

        int p = 3;
        head = rotateDLL(head, p);
        printList(head);
    }
}

Python

# Python program to rotate a doubly-linked
# list counter-clockwise
class Node:
    def __init__(self, x):
        self.data = x
        self.prev = None
        self.next = None

def rotateDLL(head, p):

    curr = head

    # Traverse to the p-th node
    for i in range(1, p):
        curr = curr.next

    if not curr or not curr.next:
        return head

    # Update pointers to perform the rotation
    newHead = curr.next
    newHead.prev = None
    curr.next = None

    tail = newHead
    while tail.next:
        tail = tail.next

    # Connect the old tail to the old head
    tail.next = head
    head.prev = tail

    return newHead

def printList(head):
    curr = head
    while curr:
        print(curr.data, end="")
        if curr.next:
            print(" ", end="")
        curr = curr.next
    print()

if __name__ == "__main__":

    head = Node(2)
    head.next = Node(6)
    head.next.prev = head
    head.next.next = Node(5)
    head.next.next.prev = head.next
    head.next.next.next = Node(4)
    head.next.next.next.prev = head.next.next

    p = 3
    head = rotateDLL(head, p)
    printList(head)

// C# program to rotate a doubly-linked 
// list counter-clockwise
using System;

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

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

class GfG {
  
    // Function to rotate the doubly-linked list
    static Node rotateDLL(Node head, int p) {
     
        Node curr = head;

        // Traverse to the p-th node
        for (int i = 1; i < p; i++) {
            curr = curr.next;
        }

        if (curr == null || curr.next == null)
            return head;

        // Update pointers to perform the rotation
        Node newHead = curr.next;
        newHead.prev = null;
        curr.next = null;

        Node tail = newHead;
        while (tail.next != null) {
            tail = tail.next;
        }

        // Connect the old tail to the old head
        tail.next = head;
        head.prev = tail;

        return newHead;
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data);
            if (curr.next != null)
                Console.Write(" ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main(string[] args) {
  
        Node head = new Node(2);
        head.next = new Node(6);
        head.next.prev = head;
        head.next.next = new Node(5);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(4);
        head.next.next.next.prev = head.next.next;

        int p = 3;
        head = rotateDLL(head, p);
        printList(head);
    }
}

JavaScript

// JavaScript program to rotate a doubly-linked 
// list counter-clockwise
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

// Function to rotate the doubly-linked list
function rotateDLL(head, p) {
    let curr = head;

    // Traverse to the p-th node
    for (let i = 1; i < p; i++) {
        curr = curr.next;
    }

    if (!curr || !curr.next) return start;

    // Update pointers to perform the rotation
    let newHead = curr.next;
    newHead.prev = null;
    curr.next = null;

    let tail = newHead;
    while (tail.next) {
        tail = tail.next;
    }

    // Connect the old tail to the old head
    tail.next = head;
    head.prev = tail;

    return newHead;
}

function printList(head) {
    let curr = head;
    while (curr) {
        console.log(curr.data);
        if (curr.next) console.log(" ");
        curr = curr.next;
    }
    console.log();
}

let head = new Node(2);
head.next = new Node(6);
head.next.prev = head;
head.next.next = new Node(5);
head.next.next.prev = head.next;
head.next.next.next = new Node(4);
head.next.next.next.prev = head.next.next;

const p = 3;
head = rotateDLL(head, p);
printList(head);

Output

4 2 6 5

Analysis of Algorithms

Mr.Gera

Improve

Article Tags :

Practice Tags :

Rotate Doubly linked list by N nodes

[Expected Approach - 1] Making a Circular DLL - O(n) Time and O(1) Space

[Expected Approach - 2] Break at pth node and Link - O(n) Time and O(1) Space

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?

[Expected Approach - 2] Break at p^th node and Link - O(n) Time and O(1) Space