Reverse a linked list
- Difficulty Level : Medium
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 the 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->NULLInput: Head of following linked list
1->2->3->4->5->NULL
Output: Linked list should be changed to,
5->4->3->2->1->NULLInput: NULL
Output: NULLInput: 1->NULL
Output: 1->NULL
Iterative Method
- Initialize three pointers prev as NULL, curr as head and next as NULL.
- Iterate through the linked list. In loop, do following.
// Before changing next of current,
// store next node
next = curr->next
// Now change next of current
// This is where actual reversing happens
curr->next = prev
// Move prev and curr one step forward
prev = curr
curr = next
Below is the implementation of the above approach:
C++
// Iterative C++ program to reverse a linked list
#include <iostream>
using
namespace
std;
/* Link list node */
struct
Node {
int
data;
struct
Node* next;
Node(
int
data)
{
this
->data = data;
next = NULL;
}
};
struct
LinkedList {
Node* head;
LinkedList() { head = NULL; }
/* Function to reverse the linked list */
void
reverse()
{
// Initialize current, previous and next pointers
Node* current = head;
Node *prev = NULL, *next = NULL;
while
(current != NULL) {
// Store next
next = current->next;
// Reverse current node's pointer
current->next = prev;
// Move pointers one position ahead.
prev = current;
current = next;
}
head = prev;
}
/* Function to print linked list */
void
print()
{
struct
Node* temp = head;
while
(temp != NULL) {
cout << temp->data <<
" "
;
temp = temp->next;
}
}
void
push(
int
data)
{
Node* temp =
new
Node(data);
temp->next = head;
head = temp;
}
};
/* Driver code*/
int
main()
{
/* Start with the empty list */
LinkedList ll;
ll.push(20);
ll.push(4);
ll.push(15);
ll.push(85);
cout <<
"Given linked list\n"
;
ll.print();
ll.reverse();
cout <<
"\nReversed Linked list \n"
;
ll.print();
return
0;
}
C
// Iterative C program to reverse a linked list
#include <stdio.h>
#include <stdlib.h>
/* Link list node */
struct
Node {
int
data;
struct
Node* next;
};
/* Function to reverse the linked list */
static
void
reverse(
struct
Node** head_ref)
{
struct
Node* prev = NULL;
struct
Node* current = *head_ref;
struct
Node* next = NULL;
while
(current != NULL) {
// Store next
next = current->next;
// Reverse current node's pointer
current->next = prev;
// Move pointers one position ahead.
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void
push(
struct
Node** head_ref,
int
new_data)
{
struct
Node* new_node
= (
struct
Node*)
malloc
(
sizeof
(
struct
Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
/* Function to print linked list */
void
printList(
struct
Node* head)
{
struct
Node* temp = head;
while
(temp != NULL) {
printf
(
"%d "
, temp->data);
temp = temp->next;
}
}
/* Driver code*/
int
main()
{
/* Start with the empty list */
struct
Node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf
(
"Given linked list\n"
);
printList(head);
reverse(&head);
printf
(
"\nReversed Linked list \n"
);
printList(head);
getchar
();
}
Java
// Java program for reversing the linked list
class
LinkedList {
static
Node head;
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;
}
}
// Driver Code
public
static
void
main(String[] args)
{
LinkedList list =
new
LinkedList();
list.head =
new
Node(
85
);
list.head.next =
new
Node(
15
);
list.head.next.next =
new
Node(
4
);
list.head.next.next.next =
new
Node(
20
);
System.out.println(
"Given Linked list"
);
list.printList(head);
head = list.reverse(head);
System.out.println(
""
);
System.out.println(
"Reversed linked list "
);
list.printList(head);
}
}
// 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
class
LinkedList:
# Function to initialize head
def
__init__(
self
):
self
.head
=
None
# Function to reverse the linked list
def
reverse(
self
):
prev
=
None
current
=
self
.head
while
(current
is
not
None
):
next
=
current.
next
current.
next
=
prev
prev
=
current
current
=
next
self
.head
=
prev
# Function to insert a new node at the beginning
def
push(
self
, new_data):
new_node
=
Node(new_data)
new_node.
next
=
self
.head
self
.head
=
new_node
# Utility function to print the linked LinkedList
def
printList(
self
):
temp
=
self
.head
while
(temp):
temp.data,
temp
=
temp.
next
# Driver code
llist
=
LinkedList()
llist.push(
20
)
llist.push(
4
)
llist.push(
15
)
llist.push(
85
)
"Given Linked List"
llist.printList()
llist.reverse()
"\nReversed Linked List"
llist.printList()
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)
C#
// C# program for reversing the linked list
using
System;
class
GFG {
// Driver Code
static
void
Main(
string
[] args)
{
LinkedList list =
new
LinkedList();
list.AddNode(
new
LinkedList.Node(85));
list.AddNode(
new
LinkedList.Node(15));
list.AddNode(
new
LinkedList.Node(4));
list.AddNode(
new
LinkedList.Node(20));
// List before reversal
Console.WriteLine(
"Given linked list:"
);
list.PrintList();
// Reverse the list
list.ReverseList();
// List after reversal
Console.WriteLine(
"Reversed linked list:"
);
list.PrintList();
}
}
class
LinkedList {
Node head;
public
class
Node {
public
int
data;
public
Node next;
public
Node(
int
d)
{
data = d;
next =
null
;
}
}
// function to add a new node at
// the end of the list
public
void
AddNode(Node node)
{
if
(head ==
null
)
head = node;
else
{
Node temp = head;
while
(temp.next !=
null
) {
temp = temp.next;
}
temp.next = node;
}
}
// function to reverse the list
public
void
ReverseList()
{
Node prev =
null
, current = head, next =
null
;
while
(current !=
null
) {
next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
}
// function to print the list data
public
void
PrintList()
{
Node current = head;
while
(current !=
null
) {
Console.Write(current.data +
" "
);
current = current.next;
}
Console.WriteLine();
}
}
// This code is contributed by Mayank Sharma
Javascript
<script>
// JavaScript program for reversing the linked list
var
head;
class Node {
constructor(val) {
this
.data = val;
this
.next =
null
;
}
}
/* Function to reverse the linked list */
function
reverse(node) {
var
prev =
null
;
var
current = node;
var
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
function
printList(node) {
while
(node !=
null
) {
document.write(node.data +
" "
);
node = node.next;
}
}
// Driver Code
head =
new
Node(85);
head.next =
new
Node(15);
head.next.next =
new
Node(4);
head.next.next.next =
new
Node(20);
document.write(
"Given Linked list<br/>"
);
printList(head);
head = reverse(head);
document.write(
"<br/>"
);
document.write(
"Reversed linked list<br/> "
);
printList(head);
// This code is contributed by todaysgaurav
</script>
Output:
Given linked list 85 15 4 20 Reversed Linked list 20 4 15 85Time Complexity: O(n)
Auxiliary Space: 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. 3) Link rest to first. 4) Fix head pointer
C++
// Recursive C++ program to reverse
// a linked list
#include <iostream>
using
namespace
std;
/* Link list node */
struct
Node {
int
data;
struct
Node* next;
Node(
int
data)
{
this
->data = data;
next = NULL;
}
};
struct
LinkedList {
Node* head;
LinkedList()
{
head = NULL;
}
Node* reverse(Node* head)
{
if
(head == NULL || head->next == NULL)
return
head;
/* reverse the rest list and put
the first element at the end */
Node* rest = reverse(head->next);
head->next->next = head;
/* tricky step -- see the diagram */
head->next = NULL;
/* fix the head pointer */
return
rest;
}
/* Function to print linked list */
void
print()
{
struct
Node* temp = head;
while
(temp != NULL) {
cout << temp->data <<
" "
;
temp = temp->next;
}
}
void
push(
int
data)
{
Node* temp =
new
Node(data);
temp->next = head;
head = temp;
}
};
/* Driver program to test above function*/
int
main()
{
/* Start with the empty list */
LinkedList ll;
ll.push(20);
ll.push(4);
ll.push(15);
ll.push(85);
cout <<
"Given linked list\n"
;
ll.print();
ll.head = ll.reverse(ll.head);
cout <<
"\nReversed Linked list \n"
;
ll.print();
return
0;
}
Java
// Recursive Java program to reverse
// a linked list
class
recursion {
static
Node head;
// head of list
static
class
Node {
int
data;
Node next;
Node(
int
d)
{
data = d;
next =
null
;
}
}
static
Node reverse(Node head)
{
if
(head ==
null
|| head.next ==
null
)
return
head;
/* reverse the rest list and put
the first element at the end */
Node rest = reverse(head.next);
head.next.next = head;
/* tricky step -- see the diagram */
head.next =
null
;
/* fix the head pointer */
return
rest;
}
/* Function to print linked list */
static
void
print()
{
Node temp = head;
while
(temp !=
null
) {
System.out.print(temp.data +
" "
);
temp = temp.next;
}
System.out.println();
}
static
void
push(
int
data)
{
Node temp =
new
Node(data);
temp.next = head;
head = temp;
}
/* Driver program to test above function*/
public
static
void
main(String args[])
{
/* Start with the empty list */
push(
20
);
push(
4
);
push(
15
);
push(
85
);
System.out.println(
"Given linked list"
);
print();
head = reverse(head);
System.out.println(
"Reversed Linked list"
);
print();
}
}
// This code is contributed by Prakhar Agarwal
Python3
"""Python3 program to reverse linked list
using recursive method"""
# Linked List Node
class
Node:
def
__init__(
self
, data):
self
.data
=
data
self
.
next
=
None
# Create and Handle list operations
class
LinkedList:
def
__init__(
self
):
self
.head
=
None
# Head of list
# Method to reverse the list
def
reverse(
self
, head):
# If head is empty or has reached the list end
if
head
is
None
or
head.
next
is
None
:
return
head
# Reverse the rest list
rest
=
self
.reverse(head.
next
)
# Put first element at the end
head.
next
.
next
=
head
head.
next
=
None
# Fix the header pointer
return
rest
# Returns the linked list in display format
def
__str__(
self
):
linkedListStr
=
""
temp
=
self
.head
while
temp:
linkedListStr
=
(linkedListStr
+
str
(temp.data)
+
" "
)
temp
=
temp.
next
return
linkedListStr
# Pushes new data to the head of the list
def
push(
self
, data):
temp
=
Node(data)
temp.
next
=
self
.head
self
.head
=
temp
# Driver code
linkedList
=
LinkedList()
linkedList.push(
20
)
linkedList.push(
4
)
linkedList.push(
15
)
linkedList.push(
85
)
(
"Given linked list"
)
(linkedList)
linkedList.head
=
linkedList.reverse(linkedList.head)
(
"Reversed linked list"
)
(linkedList)
# This code is contributed by Debidutta Rath
C#
// Recursive C# program to
// reverse a linked list
using
System;
class
recursion{
// Head of list
static
Node head;
public
class
Node
{
public
int
data;
public
Node next;
public
Node(
int
d)
{
data = d;
next =
null
;
}
}
static
Node reverse(Node head)
{
if
(head ==
null
||
head.next ==
null
)
return
head;
// Reverse the rest list and put
// the first element at the end
Node rest = reverse(head.next);
head.next.next = head;
// Tricky step --
// see the diagram
head.next =
null
;
// Fix the head pointer
return
rest;
}
// Function to print
// linked list
static
void
print()
{
Node temp = head;
while
(temp !=
null
)
{
Console.Write(temp.data +
" "
);
temp = temp.next;
}
Console.WriteLine();
}
static
void
push(
int
data)
{
Node temp =
new
Node(data);
temp.next = head;
head = temp;
}
// Driver code
public
static
void
Main(String []args)
{
// Start with the
// empty list
push(20);
push(4);
push(15);
push(85);
Console.WriteLine(
"Given linked list"
);
print();
head = reverse(head);
Console.WriteLine(
"Reversed Linked list"
);
print();
}
}
// This code is contributed by gauravrajput1
Javascript
<script>
// Recursive javascript program to reverse
// a linked list
var
head;
// head of list
class Node {
constructor(val) {
this
.data = val;
this
.next =
null
;
}
}
function
reverse(head) {
if
(head ==
null
|| head.next ==
null
)
return
head;
/*
* reverse the rest list and put the first element at the end
*/
var
rest = reverse(head.next);
head.next.next = head;
/* tricky step -- see the diagram */
head.next =
null
;
/* fix the head pointer */
return
rest;
}
/* Function to print linked list */
function
print() {
var
temp = head;
while
(temp !=
null
) {
document.write(temp.data +
" "
);
temp = temp.next;
}
document.write();
}
function
push(data) {
var
temp =
new
Node(data);
temp.next = head;
head = temp;
}
/* Driver program to test above function */
/* Start with the empty list */
push(20);
push(4);
push(15);
push(85);
document.write(
"Given linked list<br/>"
);
print();
head = reverse(head);
document.write(
"<br/>Reversed Linked list<br/>"
);
print();
// This code is contributed by Rajput-Ji
</script>
Output:
Given linked list 85 15 4 20 Reversed Linked list 20 4 15 85Time Complexity: O(n)
Auxiliary Space: O(n)A Simpler and Tail Recursive Method
Below is the implementation of this method.
C++
// A simple and tail recursive C++ program to reverse
// a linked list
#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
void
reverse(Node** head)
{
if
(!head)
return
;
reverseUtil(*head, NULL, head);
}
// 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) {
*head = curr;
/* 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;
reverseUtil(next, curr, head);
}
// 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
void
printlist(Node* head)
{
while
(head != NULL) {
cout << head->data <<
" "
;
head = head->next;
}
cout << endl;
}
// Driver code
int
main()
{
Node* head1 = newNode(1);
head1->next = newNode(2);
head1->next->next = newNode(3);
head1->next->next->next = newNode(4);
head1->next->next->next->next = newNode(5);
head1->next->next->next->next->next = newNode(6);
head1->next->next->next->next->next->next = newNode(7);
head1->next->next->next->next->next->next->next = newNode(8);
cout <<
"Given linked list\n"
;
printlist(head1);
reverse(&head1);
cout <<
"\nReversed linked list\n"
;
printlist(head1);
return
0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
C
// A simple and tail recursive C program to reverse a linked list
#include <stdio.h>
#include <stdlib.h>
typedef
struct
Node {
int
data;
struct
Node* next;
}Node;
void
reverseUtil(Node* curr, Node* prev, Node** head);
// This function mainly calls reverseUtil()
// with prev as NULL
void
reverse(Node** head)
{
if
(!head)
return
;
reverseUtil(*head, NULL, head);
}
// 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) {
*head = curr;
/* 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;
reverseUtil(next, curr, head);
}
// A utility function to create a new node
Node* newNode(
int
key)
{
Node* temp = (Node *)
malloc
(
sizeof
(Node));
temp->data = key;
temp->next = NULL;
return
temp;
}
// A utility function to print a linked list
void
printlist(Node* head)
{
while
(head != NULL) {
printf
(
"%d "
,head->data);
head = head->next;
}
printf
(
"\n"
);
}
// Driver code
int
main()
{
Node* head1 = newNode(1);
head1->next = newNode(2);
head1->next->next = newNode(3);
head1->next->next->next = newNode(4);
head1->next->next->next->next = newNode(5);
head1->next->next->next->next->next = newNode(6);
head1->next->next->next->next->next->next = newNode(7);
head1->next->next->next->next->next->next->next = newNode(8);
printf
(
"Given linked list\n"
);
printlist(head1);
reverse(&head1);
printf
(
"\nReversed linked list\n"
);
printlist(head1);
return
0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
Java
// Java program for reversing the Linked list
class
LinkedList {
static
Node head;
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 head is initially null OR list is empty*/
if
(head ==
null
)
return
head;
/* If last node mark it head*/
if
(curr.next ==
null
) {
head = curr;
/* Update next to prev node */
curr.next = prev;
return
head;
}
/* Save curr->next node for recursive call */
Node next1 = curr.next;
/* and update next ..*/
curr.next = prev;
reverseUtil(next1, curr);
return
head;
}
// prints content of double 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();
list.head =
new
Node(
1
);
list.head.next =
new
Node(
2
);
list.head.next.next =
new
Node(
3
);
list.head.next.next.next =
new
Node(
4
);
list.head.next.next.next.next =
new
Node(
5
);
list.head.next.next.next.next.next =
new
Node(
6
);
list.head.next.next.next.next.next.next =
new
Node(
7
);
list.head.next.next.next.next.next.next.next =
new
Node(
8
);
System.out.println(
"Original Linked list "
);
list.printList(head);
Node res = list.reverseUtil(head,
null
);
System.out.println(
""
);
System.out.println(
""
);
System.out.println(
"Reversed linked list "
);
list.printList(res);
}
}
// This code is contributed by Aditya Kumar (adityakumar129)
Python
# Simple and tail recursive Python program to
# reverse a linked list
# Node class
class
Node:
# Constructor to initialize the node object
def
__init__(
self
, data):
self
.data
=
data
self
.
next
=
None
class
LinkedList:
# Function to initialize head
def
__init__(
self
):
self
.head
=
None
def
reverseUtil(
self
, curr, prev):
# If last node mark it head
if
curr.
next
is
None
:
self
.head
=
curr
# 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
):
if
self
.head
is
None
:
return
self
.reverseUtil(
self
.head,
None
)
# Function to insert a new node at the beginning
def
push(
self
, new_data):
new_node
=
Node(new_data)
new_node.
next
=
self
.head
self
.head
=
new_node
# Utility function to print the linked LinkedList
def
printList(
self
):
temp
=
self
.head
while
(temp):
temp.data,
temp
=
temp.
next
# Driver code
llist
=
LinkedList()
llist.push(
8
)
llist.push(
7
)
llist.push(
6
)
llist.push(
5
)
llist.push(
4
)
llist.push(
3
)
llist.push(
2
)
llist.push(
1
)
"Given linked list"
llist.printList()
llist.reverse()
"\nReverse linked list"
llist.printList()
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)
C#
// C# program for reversing the Linked list
using
System;
public
class
LinkedList {
Node head;
public
class
Node {
public
int
data;
public
Node next;
public
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
) {
head = curr;
/* Update next to prev node */
curr.next = prev;
return
head;
}
/* Save curr->next node for recursive call */
Node next1 = curr.next;
/* and update next ..*/
curr.next = prev;
reverseUtil(next1, curr);
return
head;
}
// prints content of double linked list
void
printList(Node node)
{
while
(node !=
null
) {
Console.Write(node.data +
" "
);
node = node.next;
}
}
// Driver code
public
static
void
Main(String[] args)
{
LinkedList list =
new
LinkedList();
list.head =
new
Node(1);
list.head.next =
new
Node(2);
list.head.next.next =
new
Node(3);
list.head.next.next.next =
new
Node(4);
list.head.next.next.next.next =
new
Node(5);
list.head.next.next.next.next.next =
new
Node(6);
list.head.next.next.next.next.next.next
=
new
Node(7);
list.head.next.next.next.next.next.next.next
=
new
Node(8);
Console.WriteLine(
"Original Linked list "
);
list.printList(list.head);
Node res = list.reverseUtil(list.head,
null
);
Console.WriteLine(
""
);
Console.WriteLine(
""
);
Console.WriteLine(
"Reversed linked list "
);
list.printList(res);
}
}
// This code contributed by Rajput-Ji
Javascript
<script>
// javascript program for reversing the Linked list
var
head;
class Node {
constructor(d) {
this
.data = d;
this
.next =
null
;
}
}
// A simple and tail recursive function to reverse
// a linked list. prev is passed as NULL initially.
function
reverseUtil(curr, prev)
{
/* If head is initially null OR list is empty */
if
(head ==
null
)
return
head;
/* If last node mark it head */
if
(curr.next ==
null
) {
head = curr;
/* Update next to prev node */
curr.next = prev;
return
head;
}
/* Save curr->next node for recursive call */
var
next1 = curr.next;
/* and update next .. */
curr.next = prev;
reverseUtil(next1, curr);
return
head;
}
// prints content of var linked list
function
printList(node) {
while
(node !=
null
) {
document.write(node.data +
" "
);
node = node.next;
}
}
// Driver Code
var
head =
new
Node(1);
head.next =
new
Node(2);
head.next.next =
new
Node(3);
head.next.next.next =
new
Node(4);
head.next.next.next.next =
new
Node(5);
head.next.next.next.next.next =
new
Node(6);
head.next.next.next.next.next.next =
new
Node(7);
head.next.next.next.next.next.next.next =
new
Node(8);
document.write(
"Original Linked list<br/> "
);
printList(head);
var
res = reverseUtil(head,
null
);
document.write(
"<br/>"
);
document.write(
"<br/>"
);
document.write(
"Reversed linked list <br/>"
);
printList(res);
// This code is contributed by Rajput-Ji
</script>
OutputGiven linked list 1 2 3 4 5 6 7 8 Reversed linked list 8 7 6 5 4 3 2 1Time Complexity: O(N)
As we do certain operation for every node of the linked list.
Auxiliary Space: O(1)
As constant extra space is used.
Head Recursive Method:
C++
// Head recursive C++ program to reverse a linked list
#include <iostream>
using
namespace
std;
// Linked list node
class
Node {
public
:
int
data;
Node* next;
// constructor: automatically assigns the value to the
// data and next pointer to NULL
Node(){};
Node(
int
val)
: data(val)
, next(NULL){};
};
void
reverseUtil(Node* curr, Node* prev, Node** headref)
{
// Base Case - If curr is last node
if
(curr->next == NULL) {
// Update head of the linked list
*headref = curr;
// Update next to prev node
curr->next = prev;
return
;
}
// Recursive Call for next node
reverseUtil(curr->next, curr, headref);
// Update next to prev node
curr->next = prev;
}
void
reverse(Node** headref)
{
// If linked list is empty or contains single node
if
(*headref == NULL || (*headref)->next == NULL)
return
;
// Call reverseUtil() with prev as NULL
reverseUtil(*headref, NULL, headref);
}
// Function to insert a node at the end of linked list
void
push(Node** headref,
int
x)
{
Node* newptr =
new
Node(x);
if
(*headref == NULL) {
*headref = newptr;
}
else
{
Node* temp = *headref;
while
(temp->next != NULL) {
temp = temp->next;
}
temp->next = newptr;
}
}
// Functio to print the linked list
void
print(Node* headref)
{
while
(headref != NULL) {
cout << headref->data <<
" "
;
headref = headref->next;
}
cout <<
"\n"
;
}
int
main()
{
Node* head = NULL;
// head->1->2->3->4->5->6->NULL
push(&head, 1);
push(&head, 2);
push(&head, 3);
push(&head, 4);
push(&head, 5);
push(&head, 6);
cout <<
"Given Linked List\n"
;
print(head);
reverse(&head);
cout <<
"Reversed Linked List\n"
;
print(head);
return
0;
}
//This code is contributed by Anisha Wagh
Output:
Given Linked List 1 2 3 4 5 6 Reversed Linked List 6 5 4 3 2 1Time Complexity : O(N)
Using Stack:
Algorithm –
- Store the nodes(values and address) in the stack until all the values are entered.
- Once all entries are done, Update the Head pointer to the last location(i.e the last value).
- Start popping the nodes(value and address) and store them in the same order until the stack is empty.
- Update the next pointer of last Node in the stack by NULL.
Below is the implementation of the above approach:
C++
// C++ program for above approach
#include <bits/stdc++.h>
#include <iostream>
using
namespace
std;
// Create a class Node to enter values and address in the list
class
Node {
public
:
int
data;
Node* next;
};
// Function to reverse the linked list
void
reverseLL(Node** head)
{
// Create a stack "s" of Node type
stack<Node*> s;
Node* temp = *head;
while
(temp->next != NULL) {
// Push all the nodes in to stack
s.push(temp);
temp = temp->next;
}
*head = temp;
while
(!s.empty()) {
// Store the top value of stack in list
temp->next = s.top();
// Pop the value from stack
s.pop();
// update the next pointer in the in the list
temp = temp->next;
}
temp->next = NULL;
}
// Function to Display the elements in List
void
printlist(Node* temp)
{
while
(temp != NULL) {
cout << temp->data <<
" "
;
temp = temp->next;
}
}
// Program to insert back of the linked list
void
insert_back(Node** head,
int
value)
{
// we have used insertion at back method to enter values
// in the list.(eg: head->1->2->3->4->Null)
Node* temp =
new
Node();
temp->data = value;
temp->next = NULL;
// If *head equals to NULL
if
(*head == NULL) {
*head = temp;
return
;
}
else
{
Node* last_node = *head;
while
(last_node->next != NULL)
last_node = last_node->next;
last_node->next = temp;
return
;
}
}
// Driver Code
int
main()
{
Node* head = NULL;
insert_back(&head, 1);
insert_back(&head, 2);
insert_back(&head, 3);
insert_back(&head, 4);
cout <<
"Given linked list\n"
;
printlist(head);
reverseLL(&head);
cout <<
"\nReversed linked list\n"
;
printlist(head);
return
0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
Java
// Java program for above approach
import
java.util.*;
class
GFG {
// Create a class Node to enter values and address in the list
static
class
Node {
int
data;
Node next;
};
static
Node head =
null
;
// Function to reverse the linked list
static
void
reverseLL()
{
// Create a stack "s" of Node type
Stack<Node> s =
new
Stack<>();
Node temp = head;
while
(temp.next !=
null
) {
// Push all the nodes in to stack
s.add(temp);
temp = temp.next;
}
head = temp;
while
(!s.isEmpty()) {
// Store the top value of stack in list
temp.next = s.peek();
// Pop the value from stack
s.pop();
// update the next pointer in the in the list
temp = temp.next;
}
temp.next =
null
;
}
// Function to Display the elements in List
static
void
printlist(Node temp)
{
while
(temp !=
null
) {
System.out.print(temp.data +
" "
);
temp = temp.next;
}
}
// Program to insert back of the linked list
static
void
insert_back(
int
value)
{
// we have used insertion at back method to enter
// values in the list.(eg: head.1.2.3.4.Null)
Node temp =
new
Node();
temp.data = value;
temp.next =
null
;
// If *head equals to null
if
(head ==
null
) {
head = temp;
return
;
}
else
{
Node last_node = head;
while
(last_node.next !=
null
)
last_node = last_node.next;
last_node.next = temp;
return
;
}
}
// Driver Code
public
static
void
main(String[] args)
{
insert_back(
1
);
insert_back(
2
);
insert_back(
3
);
insert_back(
4
);
System.out.print(
"Given linked list\n"
);
printlist(head);
reverseLL();
System.out.print(
"\nReversed linked list\n"
);
printlist(head);
}
}
// This code is contributed by Aditya Kumar (adityakumar129)
C#
// C# program for above approach
using
System;
using
System.Collections.Generic;
class
GFG{
// Create a class Node to enter
// values and address in the list
public
class
Node
{
public
int
data;
public
Node next;
};
static
Node head =
null
;
// Function to reverse the
// linked list
static
void
reverseLL()
{
// Create a stack "s"
// of Node type
Stack<Node> s =
new
Stack<Node>();
Node temp = head;
while
(temp.next !=
null
)
{
// Push all the nodes
// in to stack
s.Push(temp);
temp = temp.next;
}
head = temp;
while
(s.Count != 0)
{
// Store the top value of
// stack in list
temp.next = s.Peek();
// Pop the value from stack
s.Pop();
// Update the next pointer in the
// in the list
temp = temp.next;
}
temp.next =
null
;
}
// Function to Display
// the elements in List
static
void
printlist(Node temp)
{
while
(temp !=
null
)
{
Console.Write(temp.data +
" "
);
temp = temp.next;
}
}
// Function to insert back of the
// linked list
static
void
insert_back(
int
value)
{
// We have used insertion at back method
// to enter values in the list.(eg:
// head.1.2.3.4.Null)
Node temp =
new
Node();
temp.data = value;
temp.next =
null
;
// If *head equals to null
if
(head ==
null
)
{
head = temp;
return
;
}
else
{
Node last_node = head;
while
(last_node.next !=
null
)
{
last_node = last_node.next;
}
last_node.next = temp;
return
;
}
}
// Driver Code
public
static
void
Main(String[] args)
{
insert_back(1);
insert_back(2);
insert_back(3);
insert_back(4);
Console.Write(
"Given linked list\n"
);
printlist(head);
reverseLL();
Console.Write(
"\nReversed linked list\n"
);
printlist(head);
}
}
// This code is contributed by gauravrajput1
Python3
# Python code for the above approach
# Definition for singly-linked list.
class
ListNode:
def
__init__(
self
, val
=
0
,
next
=
None
):
self
.val
=
val
self
.
next
=
next
class
Solution:
# Program to reverse the linked list
# using stack
def
reverseLLUsingStack(
self
, head):
# Initialise the variables
stack, temp
=
[], head
while
temp:
stack.append(temp)
temp
=
temp.
next
head
=
temp
=
stack.pop()
# Until stack is not
# empty
while
len
(stack) >
0
:
temp.
next
=
stack.pop()
temp
=
temp.
next
temp.
next
=
None
return
head
# Driver Code
if
__name__
=
=
"__main__"
:
head
=
ListNode(
1
, ListNode(
2
, ListNode(
3
,
ListNode(
4
, ListNode(
5
)))))
obj
=
Solution()
head
=
obj.reverseLLUsingStack(head)
while
head:
(head.val, end
=
' '
)
head
=
head.
next
Javascript
<script>
// javascript program for above approach
// Create a class Node to enter
// values and address in the list
class Node
{
constructor(){
this
.data = 0;
this
.next =
null
;
}
}
var
head =
null
;
// Function to reverse the
// linked list
function
reverseLL()
{
// Create a stack "s"
// of Node type
var
s = [];
var
temp = head;
while
(temp.next !=
null
)
{
// Push all the nodes
// in to stack
s.push(temp);
temp = temp.next;
}
head = temp;
while
(s.length!=0)
{
// Store the top value of
// stack in list
temp.next = s.pop();
// update the next pointer in the
// in the list
temp = temp.next;
}
temp.next =
null
;
}
// Function to Display
// the elements in List
function
printlist(temp)
{
while
(temp !=
null
)
{
document.write(temp.data+
" "
);
temp = temp.next;
}
}
// Program to insert back of the
// linked list
function
insert_back( value)
{
// we have used insertion at back method
// to enter values in the list.(eg:
// head.1.2.3.4.Null)
var
temp =
new
Node();
temp.data = value;
temp.next =
null
;
// If *head equals to null
if
(head ==
null
)
{
head = temp;
return
;
}
else
{
var
last_node = head;
while
(last_node.next !=
null
)
{
last_node = last_node.next;
}
last_node.next = temp;
return
;
}
}
// Driver Code
insert_back(1);
insert_back(2);
insert_back(3);
insert_back(4);
document.write(
"Given linked list\n"
);
printlist(head);
reverseLL();
document.write(
"<br/>Reversed linked list\n"
);
printlist(head);
// This code is contributed by umadevi9616
</script>
OutputGiven linked list 1 2 3 4 Reversed linked list 4 3 2 1Thanks to Gaurav Ahirwar for suggesting this solution.
Time Complexity: O(N)
As we do certain operation for every node of the linked list.
Auxiliary Space: O(N)
Space is used to store the nodes in the stack.
Using array:
Algorithm :-
1. Create a linked list.
2. Count the number of nodes present in the Linked List
3. Initialize an array with the size of the count.
4. Store the elements of the Linked list in array
5. Print the array from the last index to the first.
C++
#include <bits/stdc++.h>
using
namespace
std;
typedef
struct
node {
int
val;
struct
node* next;
} node;
node* head = NULL;
// Function to return the No of nodes present in the linked list
int
count(node* head)
{
node* p = head;
int
k = 1;
while
(p != NULL) {
p = p->next;
k++;
}
return
k;
}
node* ll_reverse(node* head)
// to reverse the linked list
{
node* p = head;
long
int
i = count(head), j = 1;
long
int
arr[i];
while
(i && p != NULL) {
arr[j++] = p->val;
p = p->next;
i--;
}
j--;
while
(j)
// loop will break as soon as j=0
cout << arr[j--] <<
" "
;
return
head;
}
// Function to insert node at the end of linked list
node* insert_end(node* head,
int
data)
{
node *q = head, *p = (node*)
malloc
(
sizeof
(node));
p->val = data;
while
(q->next != NULL)
q = q->next;
q->next = p;
p->next = NULL;
return
head;
}
node* create_ll(node* head,
int
data)
// create ll
{
node* p = (node*)
malloc
(
sizeof
(node));
p->val = data;
if
(head == NULL) {
head = p;
p->next = NULL;
return
head;
}
else
{
head = insert_end(head, data);
return
head;
}
}
// Driver code
int
main()
{
int
i = 5, j = 1;
while
(i--)
head = create_ll(head, j++);
head = ll_reverse(head);
return
0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
C
#include<stdio.h>
#include<stdlib.h>
typedef
struct
node {
int
val;
struct
node* next;
} node;
node* head = NULL;
// Function to return the No of nodes present in the linked list
int
count(node* head)
{
node* p = head;
int
k = 1;
while
(p != NULL) {
p = p->next;
k++;
}
return
k;
}
node* ll_reverse(node* head)
// to reverse the linked list
{
node* p = head;
long
int
i = count(head), j = 1;
int
arr[i];
while
(i && p != NULL) {
arr[j++] = p->val;
p = p->next;
i--;
}
j--;
while
(j)
// loop will break as soon as j=0
printf
(
"%d "
,arr[j--]);
return
head;
}
// Function to insert node at the end of linked list
node* insert_end(node* head,
int
data)
{
node *q = head, *p = (node*)
malloc
(
sizeof
(node));
p->val = data;
while
(q->next != NULL)
q = q->next;
q->next = p;
p->next = NULL;
return
head;
}
node* create_ll(node* head,
int
data)
// create ll
{
node* p = (node*)
malloc
(
sizeof
(node));
p->val = data;
if
(head == NULL) {
head = p;
p->next = NULL;
return
head;
}
else
{
head = insert_end(head, data);
return
head;
}
}
// Driver code
int
main()
{
int
i = 5, j = 1;
while
(i--)
head = create_ll(head, j++);
head = ll_reverse(head);
return
0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
Java
// Java program of the above approach
class
GFG {
// Create a class Node to enter values and address in the list
static
class
node {
int
val;
node next;
};
static
node head =
null
;
// code to count the no. of nodes
static
int
count(node head)
{
node p = head;
int
k =
1
;
while
(p !=
null
) {
p = p.next;
k++;
}
return
k;
}
// to reverse the linked list
static
node ll_reverse(node head)
{
node p = head;
int
i = count(head), j =
1
;
int
[] arr =
new
int
[i];
while
(i !=
0
&& p !=
null
) {
arr[j++] = p.val;
p = p.next;
i--;
}
j--;
while
(j !=
0
)
// loop will break as soon as j=0
System.out.print(arr[j--] +
" "
);
return
head;
}
// code to insert at end of ll
static
node insert_end(node head,
int
data)
{
node q = head;
node p =
new
node();
p.val = data;
p.next =
null
;
while
(q.next !=
null
)
q = q.next;
q.next = p;
p.next =
null
;
return
head;
}
// create ll
static
node create_ll(node head,
int
data)
{
node p =
new
node();
p.next =
null
;
p.val = data;
if
(head ==
null
) {
head = p;
p.next =
null
;
return
head;
}
else
{
head = insert_end(head, data);
return
head;
}
}
public
static
void
main(String[] args)
{
int
i =
5
, j =
1
;
while
(i !=
0
) {
head = create_ll(head, j++);
i--;
}
head = ll_reverse(head);
}
}
// This code is contributed by Aditya Kumar (adityakumar129)
C#
// C# program of the above approach
using
System;
public
class
GFG {
// Create a class Node to enter
// values and address in the list
public
class
node {
public
int
val;
public
node next;
};
static
node head =
null
;
// code to count the no. of nodes
static
int
count(node head)
{
node p = head;
int
k = 1;
while
(p !=
null
) {
p = p.next;
k++;
}
return
k;
}
// to reverse the linked list
static
node ll_reverse(node head)
{
node p = head;
int
i = count(head), j = 1;
int
[] arr =
new
int
[i];
while
(i != 0 && p !=
null
) {
arr[j++] = p.val;
p = p.next;
i--;
}
j--;
while
(j != 0)
// loop will break as soon as j=0
{
Console.Write(arr[j--] +
" "
);
}
return
head;
}
// code to insert at end of ll
static
node insert_end(node head,
int
data)
{
node q = head;
node p =
new
node();
p.val = data;
p.next =
null
;
while
(q.next !=
null
) {
q = q.next;
}
q.next = p;
p.next =
null
;
return
head;
}
// create ll
static
node create_ll(node head,
int
data)
{
node p =
new
node();
p.next =
null
;
p.val = data;
if
(head ==
null
) {
head = p;
p.next =
null
;
return
head;
}
else
{
head = insert_end(head, data);
return
head;
}
}
public
static
void
Main(String[] args)
{
int
i = 5, j = 1;
while
(i != 0) {
head = create_ll(head, j++);
i--;
}
head = ll_reverse(head);
}
}
// This code is contributed by umadevi9616
Javascript
<script>
// Javascript program of the above approach
// Create a class Node to enter values and address in the list
class node {
constructor() {
this
.val =
null
;
this
.next =
null
;
}
};
let head =
null
;
// code to count the no. of nodes
function
count(head) {
let p = head;
let k = 1;
while
(p !=
null
) {
p = p.next;
k++;
}
return
k;
}
// to reverse the linked list
function
ll_reverse(head) {
let p = head;
let i = count(head), j = 1;
let arr =
new
Array(i);
while
(i != 0 && p !=
null
) {
arr[j++] = p.val;
p = p.next;
i--;
}
j--;
while
(j != 0)
// loop will break as soon as j=0
document.write(arr[j--] +
" "
);
return
head;
}
// code to insert at end of ll
function
insert_end(head, data) {
let q = head;
let p =
new
node();
p.val = data;
p.next =
null
;
while
(q.next !=
null
)
q = q.next;
q.next = p;
p.next =
null
;
return
head;
}
// create ll
function
create_ll(head, data) {
let p =
new
node();
p.next =
null
;
p.val = data;
if
(head ==
null
) {
head = p;
p.next =
null
;
return
head;
}
else
{
head = insert_end(head, data);
return
head;
}
}
let i = 5, j = 1;
while
(i != 0) {
head = create_ll(head, j++);
i--;
}
head = ll_reverse(head);
// This code is contributed by gfgking
</script>
Input : 1->2->3->4->5 Output: 5->4->3->2->1Time complexity: O(N) as we visit every node once.
Auxiliary Space: O(N) as extra space is used to store all the nodes in the array.
Recursively Reversing a linked list (A simple implementation)
Iteratively Reverse a linked list using only 2 pointers (An Interesting Method)References:
http://cslibrary.stanford.edu/105/LinkedListProblems.pdfMy Personal Notes arrow_drop_upRecommended ArticlesPage :Article Contributed By :Improved By :Article Tags :