# Reverse a Doubly Linked List

Write a C function to reverse a given Doubly Linked List

See below diagrams for example.

`     (a) Original Doubly Linked List  `

`     (b) Reversed Doubly Linked List  `

Here is a simple method for reversing a Doubly Linked List. All we need to do is swap prev and next pointers for all nodes, change prev of the head (or start) and change the head pointer in the end.

## C

```/* 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 */
{
struct Node *temp = NULL;

/* swap next and prev for all nodes of
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 )
}

/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging 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 begining,
prev is always NULL */
new_node->prev = NULL;

/* link the old list off the new node */

/* change prev of head node to new node */

/* move the head to point to the new node */
}

/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(struct Node *node)
{
while(node!=NULL)
{
printf("%d ", node->data);
node = node->next;
}
}

/* Drier program to test above functions*/
int main()
{

/* Let us create a sorted linked list to test the functions
Created linked list will be 10->8->4->2 */

/* Reverse doubly linked list */

getchar();
}
```

## Java

```// Java program to reverse a doubly linked list

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;

/* swap next and prev for all nodes of
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) {
}
}

/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging 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 begining,
prev is always NULL */
new_node.prev = null;

/* link the old list off the new node */

/* change prev of head node to new node */
}

/* move the head to point to the new node */
}

/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + " ");
node = node.next;
}
}

public static void main(String[] args) {

/* 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);

list.reverse();
System.out.println("");
System.out.println("The reversed Linked List is ");
}
}

// This code has been contributed by Mayank Jaiswal

```

## Python

```
# Program to reverse a doubly linked list

# A node of the doublly linked list
class Node:

# Constructor to create a new node
def __init__(self, data):
self.data = data
self.next = None
self.prev = None

# Constructor for empty Doubly Linked List
def __init__(self):

# Function reverse a Doubly Linked List
def reverse(self):
temp = None

# Swap next and prev for all nodes of
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:

# 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)

# 4. change prev of head node to new_node

# 5. move the head to point to the new node

def printList(self, node):
while(node is not None):
print node.data,
node = node.next

# Driver program to test the above functions
dll.push(2);
dll.push(4);
dll.push(8);
dll.push(10);

dll.reverse()

# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

```

Time Complexity: O(n)

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 size of data item(s) is more.

Please write comments if you find any of the above codes/algorithms incorrect, or find better ways to solve the same problem.

# GATE CS Corner    Company Wise Coding Practice

2.2 Average Difficulty : 2.2/5.0
Based on 121 vote(s)