Move the Kth Element in a Doubly Linked List to the End

Last Updated : 04 Dec, 2023

Given a doubly linked list and an integer K, you need to move the Kth element to the end of the list while maintaining the order of the other elements.

Examples:

Input: DLL: 2 <-> 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7 -> NULL, K = 1
Output: 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7 <-> 2 -> NULL
Explanation: We move the 1st element (with value 2) to the end of the list while preserving the order of other elements.

Input: DLL: 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6 -> NULL, K = 3
Output: 1 <-> 2 <-> 4 <-> 5 <-> 6 <-> 3 -> NULL
Explanation: we move the 3rd element (with value 3) to the end of the list, maintaining the order of other elements.

Approach: To solve the problem follow the below idea:

To reposition the Kth element to the end of a doubly linked list while preserving the order of other elements, we follow a systematic procedure.

First, we address the special case when K is equal to 1, as the first element lacks a previous node. In this case, we detach the first element from the list and relocate it to the end while updating the head pointer.
For K values greater than 1, we traverse the list to find the Kth element, keeping track of its previous node. If K exceeds the list's length, the function exits without changes.
Next, we adjust the pointers of nodes around the Kth element to bypass it, effectively removing it from its current position in the list.
Finally, we place the Kth element at the end of the list by updating its pointers to connect with the last node. This approach efficiently handles various scenarios, ensuring that the Kth element is moved to the end while maintaining the order of the remaining elements.

Steps of the approach:

Check for invalid input: Ensure the doubly linked list is not empty and K is a positive integer.
Special handling for K = 1: If K is 1, move the first element to the end and update the head pointer.
For K > 1, traverse the list to locate the Kth element while tracking its previous node.
Check if K is greater than the list's length; if so, exit without making changes.
If K is valid, adjust pointers to bypass the Kth element and remove it from its current position.
Find the last element in the list using a loop.
Make the Kth element the new last element by updating pointers.
Ensure the bidirectional linkage between the Kth element and the previous last element.
Update the last element's next pointer to connect it to the Kth element.
Set the Kth element's next pointer to null, making it the new last element in the list.

Below is the implementation for the above approach:

C++

// C++ code for the above approach: #include <bits/stdc++.h> using namespace std; // Definition for a doubly-linked list node. struct Node {     int data;     Node* next;     Node* prev; };  // Function to move the Kth element // to the end of the doubly linked list. void moveKthToEnd(Node*& head, int K) {     if (head == nullptr || K < 1) {         return; // Invalid input     }      Node* current = head;     Node* prevKth = nullptr;      if (K == 1) {         // Special case for moving the         // first element to the end         Node* newHead = head->next;         head->prev = nullptr;         Node* tail = head;         while (tail->next) {             tail = tail->next;         }         tail->next = current;         current->prev = tail;         current->next = nullptr;         head = newHead;         return;     }      for (int i = 1; i < K && current; i++) {         prevKth = current;         current = current->next;     }      // K is greater than the length of the list     if (current == nullptr) {         return;     }      // Adjust pointers to bypass     // the Kth node     if (prevKth) {         prevKth->next = current->next;     }     if (current->next) {         current->next->prev = prevKth;     }      // Move the Kth node to the end     Node* tail = head;     while (tail->next) {         tail = tail->next;     }      tail->next = current;     current->prev = tail;     current->next = nullptr; }  // Function to print the doubly linked list. void printList(Node* head) {     while (head) {         cout << head->data;         if (head->next) {             cout << " <-> ";         }         head = head->next;     }     cout << " -> NULL" << std::endl; }  // Drivers code int main() {     // Create the first example doubly     // linked list:     // 2 <-> 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7      // Create the nodes     Node* node1 = new Node{ 2, nullptr, nullptr };     Node* node2 = new Node{ 6, nullptr, node1 };     Node* node3 = new Node{ 3, nullptr, node2 };     Node* node4 = new Node{ 8, nullptr, node3 };     Node* node5 = new Node{ 11, nullptr, node4 };     Node* node6 = new Node{ 23, nullptr, node5 };     Node* node7 = new Node{ 7, nullptr, node6 };      // Connect the nodes     node1->next = node2;     node2->next = node3;     node3->next = node4;     node4->next = node5;     node5->next = node6;     node6->next = node7;      // Set the head of the list     Node* head = node1;      // Print the original list     cout << "Original List: ";     printList(head);      // Move the 5th element to the end     moveKthToEnd(head, 1);      // Print the modified list     cout << "Modified List: ";     printList(head);      return 0; }

Java

class Node {     int data;     Node next;     Node prev;      Node(int val) {         data = val;         next = null;         prev = null;     } }  public class Main {     // Function to move the Kth element to the end of the doubly linked list     static void moveKthToEnd(Node head, int K) {         if (head == null || K < 1) {             return; // Invalid input         }          Node current = head;         Node prevKth = null;          if (K == 1) {             // Special case for moving the first element to the end             Node newHead = head.next;             head.prev = null;             Node tail = head;             while (tail.next != null) {                 tail = tail.next;             }             tail.next = current;             current.prev = tail;             current.next = null;             head = newHead;             return;         }          for (int i = 1; i < K && current != null; i++) {             prevKth = current;             current = current.next;         }          // K is greater than the length of the list         if (current == null) {             return;         }          // Adjust pointers to bypass the Kth node         if (prevKth != null) {             prevKth.next = current.next;         }         if (current.next != null) {             current.next.prev = prevKth;         }          // Move the Kth node to the end         Node tail = head;         while (tail.next != null) {             tail = tail.next;         }          tail.next = current;         current.prev = tail;         current.next = null;     }      // Function to print the doubly linked list     static void printList(Node head) {         while (head != null) {             System.out.print(head.data);             if (head.next != null) {                 System.out.print(" <-> ");             }             head = head.next;         }         System.out.println(" -> NULL");     }      public static void main(String[] args) {         // Create the first example doubly linked list:         // 2 <-> 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7          // Create the nodes         Node node1 = new Node(2);         Node node2 = new Node(6);         Node node3 = new Node(3);         Node node4 = new Node(8);         Node node5 = new Node(11);         Node node6 = new Node(23);         Node node7 = new Node(7);          // Connect the nodes         node1.next = node2;         node2.next = node3;         node3.next = node4;         node4.next = node5;         node5.next = node6;         node6.next = node7;          node2.prev = node1;         node3.prev = node2;         node4.prev = node3;         node5.prev = node4;         node6.prev = node5;         node7.prev = node6;          // Set the head of the list         Node head = node1;          // Print the original list         System.out.print("Original List: ");         printList(head);          // Move the 2nd element to the end         moveKthToEnd(head, 2);          // Print the modified list         System.out.print("Modified List: ");         printList(head);     } }

Python3

class Node:     def __init__(self, val):         self.data = val         self.next = None         self.prev = None  # Function to move the Kth element to the end of the doubly linked list def moveKthToEnd(head, K):     if head is None or K < 1:         return  # Invalid input      current = head     prevKth = None      if K == 1:         # Special case for moving the first element to the end         newHead = head.next         head.prev = None         tail = head         while tail.next is not None:             tail = tail.next         tail.next = current         current.prev = tail         current.next = None         head = newHead         return      for i in range(1, K):         if current is not None:             prevKth = current             current = current.next      # K is greater than the length of the list     if current is None:         return      # Adjust pointers to bypass the Kth node     if prevKth is not None:         prevKth.next = current.next     if current.next is not None:         current.next.prev = prevKth      # Move the Kth node to the end     tail = head     while tail.next is not None:         tail = tail.next      tail.next = current     current.prev = tail     current.next = None  # Function to print the doubly linked list def printList(head):     while head is not None:         print(head.data, end="")         if head.next is not None:             print(" <-> ", end="")         head = head.next     print(" -> NULL")  node1 = Node(2) node2 = Node(6) node3 = Node(3) node4 = Node(8) node5 = Node(11) node6 = Node(23) node7 = Node(7)   node1.next = node2 node2.next = node3 node3.next = node4 node4.next = node5 node5.next = node6 node6.next = node7  node2.prev = node1 node3.prev = node2 node4.prev = node3 node5.prev = node4 node6.prev = node5 node7.prev = node6  # Set the head of the list head = node1  print("Original List: ", end="") printList(head)  # Move the 2nd element to the end moveKthToEnd(head, 2)  print("Modified List: ", end="") printList(head)

using System;  public class Node {     public int data;     public Node next;     public Node prev;      public Node(int val)     {         data = val;         next = null;         prev = null;     } }  public class MainClass {     // Function to move the Kth element to the end of the doubly linked list     static void MoveKthToEnd(Node head, int K)     {         if (head == null || K < 1)         {             return; // Invalid input         }          Node current = head;         Node prevKth = null;          if (K == 1)         {             // Special case for moving the first element to the end             Node newHead = head.next;             head.prev = null;             Node firstTail = head;             while (firstTail.next != null)             {                 firstTail = firstTail.next;             }             firstTail.next = current;             current.prev = firstTail;             current.next = null;             head = newHead;             return;         }          for (int i = 1; i < K && current != null; i++)         {             prevKth = current;             current = current.next;         }          // K is greater than the length of the list         if (current == null)         {             return;         }          // Adjust pointers to bypass the Kth node         if (prevKth != null)         {             prevKth.next = current.next;         }         if (current.next != null)         {             current.next.prev = prevKth;         }          // Move the Kth node to the end         Node tail = head;         while (tail.next != null)         {             tail = tail.next;         }          tail.next = current;         current.prev = tail;         current.next = null;     }      // Function to print the doubly linked list     static void PrintList(Node head)     {         while (head != null)         {             Console.Write(head.data);             if (head.next != null)             {                 Console.Write(" <-> ");             }             head = head.next;         }         Console.WriteLine(" -> NULL");     }      public static void Main(string[] args)     {         // Create the first example doubly linked list:         // 2 <-> 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7          // Create the nodes         Node node1 = new Node(2);         Node node2 = new Node(6);         Node node3 = new Node(3);         Node node4 = new Node(8);         Node node5 = new Node(11);         Node node6 = new Node(23);         Node node7 = new Node(7);          // Connect the nodes         node1.next = node2;         node2.next = node3;         node3.next = node4;         node4.next = node5;         node5.next = node6;         node6.next = node7;          node2.prev = node1;         node3.prev = node2;         node4.prev = node3;         node5.prev = node4;         node6.prev = node5;         node7.prev = node6;          // Set the head of the list         Node head = node1;          // Print the original list         Console.Write("Original List: ");         PrintList(head);          // Move the 2nd element to the end         MoveKthToEnd(head, 2);          // Print the modified list         Console.Write("Modified List: ");         PrintList(head);     } }

JavaScript

// Definition for a doubly-linked list node. class Node {     constructor(data, next, prev) {         this.data = data;         this.next = next;         this.prev = prev;     } }  // Function to move the Kth element // to the end of the doubly linked list. function moveKthToEnd(head, K) {     if (head === null || K < 1) {         return; // Invalid input     }      let current = head;     let prevKth = null;      if (K === 1) {         // Special case for moving the         // first element to the end         let newHead = head.next;         head.prev = null;         let tail = head;         while (tail.next) {             tail = tail.next;         }         tail.next = current;         current.prev = tail;         current.next = null;         head = newHead;         return;     }      for (let i = 1; i < K && current; i++) {         prevKth = current;         current = current.next;     }      // K is greater than the length of the list     if (current === null) {         return;     }      // Adjust pointers to bypass     // the Kth node     if (prevKth) {         prevKth.next = current.next;     }     if (current.next) {         current.next.prev = prevKth;     }      // Move the Kth node to the end     let tail = head;     while (tail.next) {         tail = tail.next;     }      tail.next = current;     current.prev = tail;     current.next = null; }  // Function to print the doubly linked list. function printList(head) {     while (head) {         console.log(head.data);         if (head.next) {             console.log(" <-> ");         }         head = head.next;     }     console.log(" -> NULL"); }  // Drivers code // Create the first example doubly // linked list: 2 <-> 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7  // Create the nodes let node1 = new Node(2, null, null); let node2 = new Node(6, null, node1); let node3 = new Node(3, null, node2); let node4 = new Node(8, null, node3); let node5 = new Node(11, null, node4); let node6 = new Node(23, null, node5); let node7 = new Node(7, null, node6);  // Connect the nodes node1.next = node2; node2.next = node3; node3.next = node4; node4.next = node5; node5.next = node6; node6.next = node7;  // Set the head of the list let head = node1;  // Print the original list console.log("Original List: "); printList(head);  // Move the 5th element to the end moveKthToEnd(head, 1);  // Print the modified list console.log("Modified List: "); printList(head);

Output

Original List: 2 <-> 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7 -> NULL Modified List: 6 <-> 3 <-> 8 <-> 11 <-> 23 <-> 7 <-> 2 -> NULL

Time Complexity: O(N) due to the traversal of the list, where N is the number of elements.
Space Complexity: O(1) as we are not using any extra space.

Move last element to front of a given Linked List

vishaldhaygude01

Improve

Article Tags :

Practice Tags :

Linked List

Move the Kth Element in a Doubly Linked List to the End

Similar Reads