Given a Doubly Linked List, the task is to reverse the given Doubly Linked List.
Example:
Input:
Output:
Follow the given steps to solve the problem using the above approach:
- Traverse the linked list using a pointer
- Swap the prev and next pointers for all nodes
- At last, change the head pointer of the doubly linked list
Below is the implementation of the above approach:
/* Program to reverse a doubly linked list */ #include <stdio.h> #include <stdlib.h> /* a node of the doubly linked list */ struct Node {
int data;
struct Node* next;
struct Node* prev;
}; /* Function to reverse a Doubly Linked List */ void reverse( struct Node** head_ref)
{ struct Node* temp = NULL;
struct Node* current = *head_ref;
/* swap next and prev for all nodes of
doubly linked list */
while (current != NULL) {
temp = current->prev;
current->prev = current->next;
current->next = temp;
current = current->prev;
}
/* Before changing head, check for the cases like empty
list and list with only one node */
if (temp != NULL)
*head_ref = temp->prev;
} /* UTILITY FUNCTIONS */ /* Function to insert a node at the beginning of the Doubly * Linked List */
void push( struct Node** head_ref, int new_data)
{ /* allocate node */
struct Node* new_node
= ( struct Node*) malloc ( sizeof ( struct Node));
/* put in the data */
new_node->data = new_data;
/* since we are adding at the beginning,
prev is always NULL */
new_node->prev = NULL;
/* link the old list of the new node */
new_node->next = (*head_ref);
/* change prev of head node to new node */
if ((*head_ref) != NULL)
(*head_ref)->prev = new_node;
/* move the head to point to the new node */
(*head_ref) = new_node;
} /* Function to print nodes in a given doubly linked list This function is same as printList() of singly linked
list */
void printList( struct Node* node)
{ while (node != NULL) {
printf ( "%d " , node->data);
node = node->next;
}
} // Driver's code int main()
{ /* Start with the empty list */
struct Node* head = NULL;
/* Let us create a sorted linked list to test the
functions Created linked list will be 10->8->4->2 */
push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);
printf ( "\n Original Linked list " );
printList(head);
// Function call
reverse(&head);
printf ( "\n Reversed Linked list " );
printList(head);
getchar ();
} |
/* C++ program to reverse a doubly linked list */ #include <bits/stdc++.h> using namespace std;
/* Node of the doubly linked list */ class Node {
public :
int data;
Node* next;
Node* prev;
}; /* Function to reverse a Doubly Linked List */ void reverse(Node** head_ref)
{ Node* temp = NULL;
Node* current = *head_ref;
/* swap next and prev for all nodes of
doubly linked list */
while (current != NULL) {
temp = current->prev;
current->prev = current->next;
current->next = temp;
current = current->prev;
}
/* Before changing the head, check for the cases like
empty list and list with only one node */
if (temp != NULL)
*head_ref = temp->prev;
} /* UTILITY FUNCTIONS */ /* Function to insert a node at the beginning of the Doubly Linked List */ void push(Node** head_ref, int new_data)
{ /* allocate node */
Node* new_node = new Node();
/* put in the data */
new_node->data = new_data;
/* since we are adding at the beginning,
prev is always NULL */
new_node->prev = NULL;
/* link the old list of the new node */
new_node->next = (*head_ref);
/* change prev of head node to new node */
if ((*head_ref) != NULL)
(*head_ref)->prev = new_node;
/* move the head to point to the new node */
(*head_ref) = new_node;
} /* Function to print nodes in a given doubly linked list This function is same as printList() of singly linked list */ void printList(Node* node)
{ while (node != NULL) {
cout << node->data << " " ;
node = node->next;
}
} // Driver's code int main()
{ /* Start with the empty list */
Node* head = NULL;
/* Let us create a sorted linked list to test the
functions Created linked list will be 10->8->4->2 */
push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);
cout << "Original Linked list" << endl;
printList(head);
// Function call
reverse(&head);
cout << "\nReversed Linked list" << endl;
printList(head);
return 0;
} // This code is contributed by rathbhupendra |
// Java program to reverse a doubly linked list class LinkedList {
static Node head;
static class Node {
int data;
Node next, prev;
Node( int d)
{
data = d;
next = prev = null ;
}
}
/* Function to reverse a Doubly Linked List */
void reverse()
{
Node temp = null ;
Node current = head;
/* swap next and prev for all nodes of
doubly linked list */
while (current != null ) {
temp = current.prev;
current.prev = current.next;
current.next = temp;
current = current.prev;
}
/* Before changing head, check for the cases like
empty list and list with only one node */
if (temp != null ) {
head = temp.prev;
}
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the
* Doubly Linked List */
void push( int new_data)
{
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the beginning,
prev is always NULL */
new_node.prev = null ;
/* link the old list of the new node */
new_node.next = head;
/* change prev of head node to new node */
if (head != null ) {
head.prev = new_node;
}
/* move the head to point to the new node */
head = new_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked
list */
void printList(Node node)
{
while (node != null ) {
System.out.print(node.data + " " );
node = node.next;
}
}
// Driver's code
public static void main(String[] args)
{
LinkedList list = new LinkedList();
/* Let us create a sorted linked list to test the
functions Created linked list will be 10->8->4->2
*/
list.push( 2 );
list.push( 4 );
list.push( 8 );
list.push( 10 );
System.out.println( "Original linked list " );
list.printList(head);
// Function call
list.reverse();
System.out.println( "" );
System.out.println( "The reversed Linked List is " );
list.printList(head);
}
} // This code has been contributed by Mayank Jaiswal |
# Python3 Program to reverse a doubly linked list # A node of the doubly linked list class Node:
# Constructor to create a new node
def __init__( self , data):
self .data = data
self . next = None
self .prev = None
class DoublyLinkedList:
# Constructor for empty Doubly Linked List
def __init__( self ):
self .head = None
# Function reverse a Doubly Linked List
def reverse( self ):
temp = None
current = self .head
# Swap next and prev for all nodes of
# doubly linked list
while current is not None :
temp = current.prev
current.prev = current. next
current. next = temp
current = current.prev
# Before changing head, check for the cases like
# empty list and list with only one node
if temp is not None :
self .head = temp.prev
# Given a reference to the head of a list and an
# integer,inserts a new node on the front of list
def push( self , new_data):
# 1. Allocates node
# 2. Put the data in it
new_node = Node(new_data)
# 3. Make next of new node as head and
# previous as None (already None)
new_node. next = self .head
# 4. change prev of head node to new_node
if self .head is not None :
self .head.prev = new_node
# 5. move the head to point to the new node
self .head = new_node
def printList( self , node):
while (node is not None ):
print (node.data, end = ' ' )
node = node. next
# Driver's code if __name__ = = "__main__" :
dll = DoublyLinkedList()
dll.push( 2 )
dll.push( 4 )
dll.push( 8 )
dll.push( 10 )
print ( "\nOriginal Linked List" )
dll.printList(dll.head)
# Function call
dll.reverse()
print ( "\nReversed Linked List" )
dll.printList(dll.head)
# This code is contributed by Nikhil Kumar Singh(nickzuck_007) |
// A C# program to reverse a doubly linked list using System;
public class LinkedList {
static Node head;
class Node {
public int data;
public Node next, prev;
public Node( int d)
{
data = d;
next = prev = null ;
}
}
/* Function to reverse a Doubly Linked List */
void reverse()
{
Node temp = null ;
Node current = head;
/* swap next and prev for all nodes of
doubly linked list */
while (current != null ) {
temp = current.prev;
current.prev = current.next;
current.next = temp;
current = current.prev;
}
/* Before changing head, check for
the cases like empty list and
list with only one node */
if (temp != null ) {
head = temp.prev;
}
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the
beginning of the Doubly Linked List */
void push( int new_data)
{
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the beginning,
prev is always NULL */
new_node.prev = null ;
/* link the old list of the new node */
new_node.next = head;
/* change prev of head node to new node */
if (head != null ) {
head.prev = new_node;
}
/* move the head to point to the new node */
head = new_node;
}
/* Function to print nodes in a given
doubly linked list This function is
same as printList() of singly linked list */
void printList(Node node)
{
while (node != null ) {
Console.Write(node.data + " " );
node = node.next;
}
}
// Driver's code
public static void Main(String[] args)
{
LinkedList list = new LinkedList();
/* Let us create a sorted linked list
to test the functions Created linked
list will be 10->8->4->2 */
list.push(2);
list.push(4);
list.push(8);
list.push(10);
Console.WriteLine( "Original linked list " );
list.printList(head);
// Function call
list.reverse();
Console.WriteLine( "" );
Console.WriteLine( "The reversed Linked List is " );
list.printList(head);
}
} // This code is contributed by 29AjayKumar |
// javascript program to reverse a doubly linked list var head;
class Node {
constructor(val) {
this .data = val;
this .prev = null ;
this .next = null ;
}
}
/* Function to reverse a Doubly Linked List */
function reverse() {
var temp = null ;
var current = head;
/*
* swap next and prev for all nodes of doubly linked list
*/
while (current != null ) {
temp = current.prev;
current.prev = current.next;
current.next = temp;
current = current.prev;
}
/*
* Before changing head, check for the cases like empty list and list with only
* one node
*/
if (temp != null ) {
head = temp.prev;
}
}
/* UTILITY FUNCTIONS */
/*
* Function to insert a node at the beginning of the Doubly Linked List
*/
function push(new_data) {
/* allocate node */
var new_node = new Node(new_data);
/*
* since we are adding at the beginning, prev is always NULL
*/
new_node.prev = null ;
/* link the old list of the new node */
new_node.next = head;
/* change prev of head node to new node */
if (head != null ) {
head.prev = new_node;
}
/* move the head to point to the new node */
head = new_node;
}
/*
* Function to print nodes in a given doubly linked list This function is same
* as printList() of singly linked list
*/
function printList(node) {
while (node != null ) {
document.write(node.data + " " );
node = node.next;
}
}
/*
* Let us create a sorted linked list to test the functions Created linked list
* will be 10->8->4->2
*/
push(2);
push(4);
push(8);
push(10);
document.write( "Original linked list <br/>" );
printList(head);
reverse();
document.write( "<br/>" );
document.write( "The reversed Linked List is <br/>" );
printList(head);
// This code contributed by gauravrajput1 |
Original Linked list 10 8 4 2 Reversed Linked list 2 4 8 10
Time Complexity: O(N), where N denotes the number of nodes in the doubly linked list.
Auxiliary Space: O(1)
We can also swap data instead of pointers to reverse the Doubly Linked List. Method used for reversing array can be used to swap data. Swapping data can be costly compared to pointers if the size of the data item(s) is more.
Reverse a Doubly Linked List using Stack:
Push the node’s data into the stack while traversing the doubly linked list, then pop out the elements from the stack and copy the value to the nodes of the linked list by again traversing it
Follow the given steps to solve the problem using the above approach:
- Traverse the whole Linked List and Keep pushing the node’s data into the stack
- Then keep popping the elements out of the stack and updating the Doubly Linked List
Below is the implementation of the above approach:
// C++ program to reverse a doubly linked list #include <bits/stdc++.h> using namespace std;
struct LinkedList {
struct Node {
int data;
Node *next, *prev;
Node( int d)
{
data = d;
next = prev = NULL;
}
};
Node* head = NULL;
/* Function to reverse a Doubly Linked List using Stacks
*/
void reverse()
{
stack< int > st;
Node* temp = head;
while (temp != NULL) {
st.push(temp->data);
temp = temp->next;
}
// added all the elements sequence wise in the
// st
temp = head;
while (temp != NULL) {
temp->data = st.top();
st.pop();
temp = temp->next;
}
// popped all the elements and the added in the
// linked list,
// which are in the reversed order->
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the
* Doubly Linked List */
void Push( int new_data)
{
/* allocate node */
Node* new_node = new Node(new_data);
/* since we are adding at the beginning,
prev is always NULL */
new_node->prev = NULL;
/* link the old list of the new node */
new_node->next = head;
/* change prev of head node to new node */
if (head != NULL) {
head->prev = new_node;
}
/* move the head to point to the new node */
head = new_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked
list */
void printList(Node* node)
{
while (node) {
cout << node->data << " " ;
node = node->next;
}
}
}; // Driver Code int main()
{ LinkedList list;
/* Let us create a sorted linked list to test the
functions Created linked list will be 10->8->4->2
*/
list.Push(2);
list.Push(4);
list.Push(8);
list.Push(10);
cout << "Original linked list " << endl;
list.printList(list.head);
list.reverse();
cout << endl;
cout << "The reversed Linked List is " << endl;
list.printList(list.head);
} // This code is contributed by Pratham76 |
// Java program to reverse a doubly linked list import java.util.*;
class LinkedList {
static Node head;
static class Node {
int data;
Node next, prev;
Node( int d)
{
data = d;
next = prev = null ;
}
}
/* Function to reverse a Doubly Linked List using Stacks
*/
void reverse()
{
Stack<Integer> stack = new Stack<>();
Node temp = head;
while (temp != null ) {
stack.push(temp.data);
temp = temp.next;
}
// added all the elements sequence wise in the
// stack
temp = head;
while (temp != null ) {
temp.data = stack.pop();
temp = temp.next;
}
// popped all the elements and the added in the
// linked list,
// which are in the reversed order.
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the
* Doubly Linked List */
void push( int new_data)
{
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the beginning,
prev is always NULL */
new_node.prev = null ;
/* link the old list of the new node */
new_node.next = head;
/* change prev of head node to new node */
if (head != null ) {
head.prev = new_node;
}
/* move the head to point to the new node */
head = new_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked
list */
void printList(Node node)
{
while (node != null ) {
System.out.print(node.data + " " );
node = node.next;
}
}
// Driver Code
public static void main(String[] args)
{
LinkedList list = new LinkedList();
/* Let us create a sorted linked list to test the
functions Created linked list will be 10->8->4->2
*/
list.push( 2 );
list.push( 4 );
list.push( 8 );
list.push( 10 );
System.out.println( "Original linked list " );
list.printList(head);
list.reverse();
System.out.println( "" );
System.out.println( "The reversed Linked List is " );
list.printList(head);
}
} // This code has been contributed by Rashita Mehta |
# Python3 code for the above approach class Node:
def __init__( self , data):
self .data = data
self . next = None
self .prev = None
class DoublyLinkedList:
def __init__( self ):
self .head = None
"""
method to reverse a Doubly-Linked List using Stacks
"""
def reverseUsingStacks( self ):
stack = []
temp = self .head
while temp is not None :
stack.append(temp.data)
temp = temp. next
# Add all the elements in the stack
# in a sequence to the stack
temp = self .head
while temp is not None :
temp.data = stack.pop()
temp = temp. next
# Popped all the elements and the
# added in the linked list,
# in a reversed order.
"""
method to push a new item before the head
"""
def push( self , new_data):
new_node = Node(new_data)
new_node. next = self .head
if self .head is not None :
self .head.prev = new_node
self .head = new_node
"""
method to traverse the doubly-linked
list and print every node in the list
"""
def printList( self , node):
while (node is not None ):
print (node.data)
node = node. next
# driver's code if __name__ = = "__main__" :
dll = DoublyLinkedList()
dll.push( 2 )
dll.push( 4 )
dll.push( 8 )
dll.push( 10 )
print ( "original doubly-linked list" )
dll.printList(dll.head)
# Function call
dll.reverseUsingStacks()
print ( " reversed doubly-linked list" )
dll.printList(dll.head)
|
// C# program to reverse a doubly linked list using System;
using System.Collections;
using System.Collections.Generic;
class LinkedList {
public static Node head;
public class Node {
public int data;
public Node next, prev;
public Node( int d)
{
data = d;
next = prev = null ;
}
}
/* Function to reverse a Doubly Linked List using Stacks
*/
public void reverse()
{
Stack stack = new Stack();
Node temp = head;
while (temp != null ) {
stack.Push(temp.data);
temp = temp.next;
}
// added all the elements sequence wise in the
// stack
temp = head;
while (temp != null ) {
temp.data = ( int )stack.Pop();
temp = temp.next;
}
// popped all the elements and the added in the
// linked list,
// which are in the reversed order.
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the
* Doubly Linked List */
public void Push( int new_data)
{
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the beginning,
prev is always NULL */
new_node.prev = null ;
/* link the old list of the new node */
new_node.next = head;
/* change prev of head node to new node */
if (head != null ) {
head.prev = new_node;
}
/* move the head to point to the new node */
head = new_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked
list */
public void printList(Node node)
{
while (node != null ) {
Console.Write(node.data + " " );
node = node.next;
}
}
// Driver's Code
public static void Main( string [] args)
{
LinkedList list = new LinkedList();
/* Let us create a sorted linked list to test the
functions Created linked list will be 10->8->4->2
*/
list.Push(2);
list.Push(4);
list.Push(8);
list.Push(10);
Console.WriteLine( "Original linked list " );
list.printList(head);
// Function call
list.reverse();
Console.WriteLine( "" );
Console.WriteLine( "The reversed Linked List is " );
list.printList(head);
}
} // This code is contributed by rutvik_56 |
// Javascript program to reverse a doubly linked list class Node { constructor(d)
{
this .data = d;
this .next = this .prev = null ;
}
} let head; // Function to reverse a Doubly // Linked List using Stacks function reverse()
{ let stack = [];
let temp = head;
while (temp != null )
{
stack.push(temp.data);
temp = temp.next;
}
// Added all the elements sequence
// wise in the stack
temp = head;
while (temp != null )
{
temp.data = stack.pop();
temp = temp.next;
}
// Popped all the elements and the
// added in the linked list,
// which are in the reversed order.
} // UTILITY FUNCTIONS // Function to insert a node at the // beginning of the Doubly Linked List function push(new_data)
{ /* Allocate node */
let new_node = new Node(new_data);
/* Since we are adding at the beginning,
prev is always NULL */
new_node.prev = null ;
/* Link the old list of the new node */
new_node.next = head;
/* Change prev of head node to new node */
if (head != null ) {
head.prev = new_node;
}
/* Move the head to point to the new node */
head = new_node;
} // Function to print nodes in a given // doubly linked list. This function // is same as printList() of singly // linked list function printList(node)
{ while (node != null )
{
document.write(node.data + " " );
node = node.next;
}
} // Driver Code // Let us create a sorted linked list // to test the functions Created linked // list will be 10->8->4->2 push(2); push(4); push(8); push(10); document.write( "Original linked list <br>" );
printList(head); reverse(); document.write( "<br>" );
document.write( "The reversed Linked List is <br>" );
printList(head); // This code is contributed by rag2127 |
Original linked list 10 8 4 2 The reversed Linked List is 2 4 8 10
Time Complexity: O(N)
Auxiliary Space: O(N)
To reverse a doubly linked list, we can follow the below algorithm:
Check if the head of the linked list is null or the next node is null. If yes, return the head of the list.
Initialize three pointers – current pointing to the head of the list, prev to null and next to null.
Traverse the linked list by moving the current pointer to the next node, and for each node, set its next pointer to point to the previous node and its prev pointer to point to the next node.
Once the traversal is complete, set the head of the list to point to the last node of the original linked list (which is now the first node of the reversed list).
Return the new head of the list.
Algorithmic Steps:
Step 1 : Create a function to reverse the linked list, which takes the head node as input. step 2 : Initialize three pointers: prevNode to NULL, currentNode to the head node, and nextNode to NULL. Step 3 : Traverse the linked list using a while loop until the currentNode pointer is not NULL. Step 4 : Inside the loop, assign nextNode as the next node of the currentNode using the next pointer. Step 5 : Set the next pointer of the currentNode to prevNode, effectively reversing the pointer direction of the currentNode. Step 6 : Update prevNode to the currentNode. Step 7 : Update currentNode to the nextNode. Step 8 :Finally, set the head node to prevNode and return it.
In this algorithm, we first check if the linked list is empty or has only one node. If yes, we return the head of the list. Then we initialize three pointers – current, prev and next – to null, the head of the list and null, respectively. Then, we traverse the linked list, setting the next and prev pointers of each node to point to the previous and next nodes, respectively. Finally, we set the head of the list to the last node of the original linked list (which is now the first node of the reversed list) and return the new head.
#include <iostream> struct Node {
int data;
Node* prev;
Node* next;
}; void reverse(Node** head_ref) {
Node* current = *head_ref;
Node* temp = NULL;
while (current != NULL) {
temp = current->prev;
current->prev = current->next;
current->next = temp;
current = current->prev;
}
if (temp != NULL) {
*head_ref = temp->prev;
}
} void printList(Node* node) {
while (node != NULL) {
std::cout << node->data << " " ;
node = node->next;
}
} int main() {
Node* head = NULL;
Node* second = NULL;
Node* third = NULL;
// allocate nodes
head = new Node();
second = new Node();
third = new Node();
// link nodes
head->data = 1;
head->prev = NULL;
head->next = second;
second->data = 2;
second->prev = head;
second->next = third;
third->data = 3;
third->prev = second;
third->next = NULL;
std::cout << "Original List: " ;
printList(head);
reverse(&head);
std::cout << "\nReversed List: " ;
printList(head);
return 0;
} |
class Node {
int data;
Node prev;
Node next;
} class Main {
static void reverse(Node[] head_ref)
{
Node current = head_ref[ 0 ];
Node temp = null ;
while (current != null ) {
temp = current.prev;
current.prev = current.next;
current.next = temp;
current = current.prev;
}
if (temp != null ) {
head_ref[ 0 ] = temp.prev;
}
}
static void printList(Node node) {
while (node != null ) {
System.out.print(node.data + " " );
node = node.next;
}
}
public static void main(String[] args)
{
Node head = null ;
Node second = null ;
Node third = null ;
// allocate nodes
head = new Node();
second = new Node();
third = new Node();
// link nodes
head.data = 1 ;
head.prev = null ;
head.next = second;
second.data = 2 ;
second.prev = head;
second.next = third;
third.data = 3 ;
third.prev = second;
third.next = null ;
System.out.print( "Original List: " );
printList(head);
Node[] head_ref = new Node[ 1 ];
head_ref[ 0 ] = head;
reverse(head_ref);
head = head_ref[ 0 ];
System.out.print( "\nReversed List: " );
printList(head);
}
} |
# Define Node class class Node:
def __init__( self ):
self .data = 0
self .prev = None
self . next = None
# Define function to reverse the doubly linked list def reverse(head_ref):
current = head_ref
temp = None
while current ! = None :
temp = current.prev
current.prev = current. next
current. next = temp
current = current.prev
if temp ! = None :
head_ref = temp.prev
return head_ref
# Define function to print the doubly linked list def printList(node):
while node ! = None :
print (node.data, end = " " )
node = node. next
# Create nodes head = Node()
second = Node()
third = Node()
# Link nodes head.data = 1
head.prev = None
head. next = second
second.data = 2
second.prev = head
second. next = third
third.data = 3
third.prev = second
third. next = None
# Print original list print ( "Original List: " , end = "")
printList(head) # Reverse the list head = reverse(head)
# Print the reversed list print ( "\nReversed List: " , end = "")
printList(head) |
using System;
public class Node {
public int data;
public Node prev;
public Node next;
} public class Program {
static void reverse( ref Node head) {
Node current = head;
Node temp = null ;
while (current != null ) {
temp = current.prev;
current.prev = current.next;
current.next = temp;
current = current.prev;
}
if (temp != null ) {
head = temp.prev;
}
}
static void printList(Node node) {
while (node != null ) {
Console.Write(node.data + " " );
node = node.next;
}
}
public static void Main( string [] args) {
Node head = null ;
Node second = null ;
Node third = null ;
// allocate nodes
head = new Node();
second = new Node();
third = new Node();
// link nodes
head.data = 1;
head.prev = null ;
head.next = second;
second.data = 2;
second.prev = head;
second.next = third;
third.data = 3;
third.prev = second;
third.next = null ;
Console.Write( "Original List: " );
printList(head);
reverse( ref head);
Console.Write( "\nReversed List: " );
printList(head);
}
} |
class Node { constructor() {
this .data = 0;
this .prev = null ;
this .next = null ;
}
} function reverse(head_ref) {
let current = head_ref;
let temp = null ;
while (current != null ) {
temp = current.prev;
current.prev = current.next;
current.next = temp;
current = current.prev;
}
if (temp != null ) {
head_ref = temp.prev;
}
return head_ref;
} function printList(node) {
while (node != null ) {
console.log(node.data + " " );
node = node.next;
}
} let head = new Node();
let second = new Node();
let third = new Node();
head.data = 1; head.prev = null ;
head.next = second; second.data = 2; second.prev = head; second.next = third; third.data = 3; third.prev = second; third.next = null ;
// Print original list console.log( "Original List: " )
printList(head) // Reverse the list head = reverse(head) // Print the reversed list console.log( "\nReversed List: " )
printList(head) |
Original List: 1 2 3 Reversed List: 3 2 1
Time and Space complexities:
reverse(Node** head_ref): This function reverses the doubly linked list. The time complexity of this function is O(n), where n is the number of nodes in the list. This is because the function visits each node once and performs a constant amount of work on each node. The space complexity of this function is O(1), as it uses a constant amount of extra memory regardless of the size of the input.
printList(Node* node): This function prints the contents of the doubly linked list. The time complexity of this function is O(n), where n is the number of nodes in the list. This is because the function visits each node once and performs a constant amount of work on each node. The space complexity of this function is O(1), as it uses a constant amount of extra memory regardless of the size of the input.
main(): This function creates a doubly linked list and then reverses it using the reverse() function. The time complexity of this function is O(n), where n is the number of nodes in the list. This is because the function calls the reverse() function, which has a time complexity of O(n), and also calls the printList() function twice, each of which has a time complexity of O(n). The space complexity of this function is O(n), as it creates a doubly linked list with n nodes and uses a constant amount of extra memory for the pointers head, second, and third.