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++ 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;
} |
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);
}
} |
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);
}
} |
// 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); |
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.