Given pointer to the head node of a linked list, the task is to reverse the linked list. We need to reverse the list by changing links between nodes.

Examples:

```Input : Head of following linked list
1->2->3->4->NULL
Output : Linked list should be changed to,
4->3->2->1->NULL

1->2->3->4->5->NULL
Output : Linked list should be changed to,
5->4->3->2->1->NULL

Input : NULL
Output : NULL

Input  : 1->NULL
Output : 1->NULL
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Iterative Method
Iterate trough the linked list. In loop, change next to prev, prev to current and current to next.

Implementation of Iterative Method

## C

```#include<stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node* next;
};

/* Function to reverse the linked list */
{
struct Node* prev   = NULL;
struct Node* next;
while (current != NULL)
{
next  = current->next;
current->next = prev;
prev = current;
current = next;
}
}

/* Function to push a node */
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;

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

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

/* Function to print linked list */
{
while(temp != NULL)
{
printf("%d  ", temp->data);
temp = temp->next;
}
}

/* Driver program to test above function*/
int main()
{

getchar();
}
```

## Java

```// Java program for reversing the linked list

static class Node {

int data;
Node next;

Node(int d) {
data = d;
next = null;
}
}

/* Function to reverse the linked list */
Node reverse(Node node) {
Node prev = null;
Node current = node;
Node next = null;
while (current != null) {
next = current.next;
current.next = prev;
prev = current;
current = next;
}
node = prev;
return node;
}

// prints content of double linked list
void printList(Node node) {
while (node != null) {
System.out.print(node.data + " ");
node = node.next;
}
}

public static void main(String[] args) {

System.out.println("");
}
}

// This code has been contributed by Mayank Jaiswal
```

## Python

```
# Python program to reverse a linked list
# Time Complexity : O(n)
# Space Complexity : O(1)

# Node class
class Node:

# Constructor to initialize the node object
def __init__(self, data):
self.data = data
self.next = None

def __init__(self):

# Function to reverse the linked list
def reverse(self):
prev = None
while(current is not None):
next = current.next
current.next = prev
prev = current
current = next

# Function to insert a new node at the beginning
def push(self, new_data):
new_node = Node(new_data)

def printList(self):
while(temp):
print temp.data,
temp = temp.next

# Driver program to test above functions
llist.push(20)
llist.push(4)
llist.push(15)
llist.push(85)

llist.printList()
llist.reverse()
llist.printList()

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

```
```Given linked list
85 15 4 20
20 4 15 85 ```

Time Complexity: O(n)
Space Complexity: O(1)

Recursive Method:

```   1) Divide the list in two parts - first node and rest of the linked list.
2) Call reverse for the rest of the linked list.
```

```void recursiveReverse(struct Node** head_ref)
{
struct Node* first;
struct Node* rest;

/* empty list */
return;

/* suppose first = {1, 2, 3}, rest = {2, 3} */
rest  = first->next;

/* List has only one node */
if (rest == NULL)
return;

/* reverse the rest list and put the first element at the end */
recursiveReverse(&rest);
first->next->next  = first;

/* tricky step -- see the diagram */
first->next  = NULL;

/* fix the head pointer */
}
```

Time Complexity: O(n)
Space Complexity: O(1)

A Simpler and Tail Recursive Method
Below is C++ implementation of this method.

## C++

```// A simple and tail recursive C++ program to reverse
#include<bits/stdc++.h>
using namespace std;

struct Node
{
int data;
struct Node *next;
};

void reverseUtil(Node *curr, Node *prev, Node **head);

// This function mainly calls reverseUtil()
// with prev as NULL
{
return;
}

// A simple and tail recursive function to reverse
// a linked list.  prev is passed as NULL initially.
void reverseUtil(Node *curr, Node *prev, Node **head)
{
/* If last node mark it head*/
if (!curr->next)
{

/* Update next to prev node */
curr->next = prev;
return;
}

/* Save curr->next node for recursive call */
node *next = curr->next;

/* and update next ..*/
curr->next = prev;

}

// A utility function to create a new node
Node *newNode(int key)
{
Node *temp = new Node;
temp->data = key;
temp->next = NULL;
return temp;
}

// A utility function to print a linked list
{
{
cout << head->data << " ";
}
cout << endl;
}

// Driver program to test above functions
int main()
{
return 0;
}
```

## Java

```// Java program for reversing the Linked list

static class Node {

int data;
Node next;

Node(int d) {
data = d;
next = null;
}
}

// A simple and tail recursive function to reverse
// a linked list.  prev is passed as NULL initially.
Node reverseUtil(Node curr, Node prev) {

/* If last node mark it head*/
if (curr.next == null) {

/* Update next to prev node */
curr.next = prev;
return null;
}

/* Save curr->next node for recursive call */
Node next1 = curr.next;

/* and update next ..*/
curr.next = prev;

reverseUtil(next1, curr);
}

// prints content of double linked list
void printList(Node node) {
while (node != null) {
System.out.print(node.data + " ");
node = node.next;
}
}

public static void main(String[] args) {

System.out.println("");
System.out.println("");
list.printList(res);
}
}

// This code has been contributed by Mayank Jaiswal

```

## Python

```
# Simple and tail recursive Python program to

# Node class
class Node:

# Constructor to initialize the node object
def __init__(self, data):
self.data = data
self.next = None

def __init__(self):

def reverseUtil(self, curr, prev):

# If last node mark it head
if curr.next is None :

# Update next to prev node
curr.next = prev
return

# Save curr.next node for recursive call
next = curr.next

# And update next
curr.next = prev

self.reverseUtil(next, curr)

# This function mainly calls reverseUtil()
# with previous as None
def reverse(self):
return

# Function to insert a new node at the beginning
def push(self, new_data):
new_node = Node(new_data)

def printList(self):
while(temp):
print temp.data,
temp = temp.next

# Driver program
llist.push(8)
llist.push(7)
llist.push(6)
llist.push(5)
llist.push(4)
llist.push(3)
llist.push(2)
llist.push(1)

llist.printList()

llist.reverse()

llist.printList()

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

```

Output:
```Given linked list
1 2 3 4 5 6 7 8

8 7 6 5 4 3 2 1```

Thanks to Gaurav Ahirwar for suggesting this solution.

Iteratively Reverse a linked list using only 2 pointers (An Interesting Method)

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2.7 Average Difficulty : 2.7/5.0
Based on 399 vote(s)