Open in App
Not now

Given a 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

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 Practice

## Reverse a linked list by Iterative Method:

The idea is to use three pointers curr, prev, and next to keep track of nodes to update reverse links.

Illustration:

Follow the steps below to solve the problem:

• Initialize three pointers prev as NULL, curr as head, and next as NULL.
• Iterate through the linked list. In a loop, do the following:
• Before changing the next of curr, store the next node
• next = curr -> next
• Now update the next pointer of curr to the prev
• curr -> next = prev
• Update prev as curr and curr as next
• prev = curr
• curr = next

Below is the implementation of the above approach:

## C++

 `// Iterative C++ program to reverse a linked list` `#include ` `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 ` `#include `   `/* 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`

## Python3

 `# 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 LinkedList` `    ``def` `printList(``self``):` `        ``temp ``=` `self``.head` `        ``while``(temp):` `            ``print``(temp.data, end``=``" "``)` `            ``temp ``=` `temp.``next`     `# Driver code` `llist ``=` `LinkedList()` `llist.push(``20``)` `llist.push(``4``)` `llist.push(``15``)` `llist.push(``85``)`   `print` `(``"Given linked list"``)` `llist.printList()` `llist.reverse()` `print` `(``"\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

 ``

Output

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

Time Complexity: O(N), Traversing over the linked list of size N.
Auxiliary Space: O(1)

## Reverse a linked list using Recursion:

The idea is to reach the last node of the linked list using recursion then start reversing the linked list.

Illustration:

Follow the steps below to solve the problem:

• Divide the list in two parts – first node and rest of the linked list.
• Call reverse for the rest of the linked list.
• Fix head pointer to NULL

Below is the implementation of above approach:

## C++

 `// Recursive C++ program to reverse` `// a linked list` `#include ` `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`   `import` `java.io.*;`   `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``)`   `print``(``"Given linked list"``)` `print``(linkedList)`   `linkedList.head ``=` `linkedList.reverse(linkedList.head)`   `print``(``"Reversed linked list"``)` `print``(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

 ``

Output

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

Time Complexity: O(N), Visiting over every node one time
Auxiliary Space: O(N), Function call stack space

## Reverse a linked list by Tail Recursive Method:

The idea is to maintain three pointers previous, current and next, recursively visit every node and make links using these three pointers.

Follow the steps below to solve the problem:

• First update next with next node of current i.e. next = current->next
• Now make a reverse link from current node to previous node i.e. curr->next = prev
• If the visited node is the last node then just make a reverse link from the current node to previous node and update head.

Below is the implementation of the above approach:

## C++

 `// A simple and tail recursive C++ program to reverse` `// a linked list` `#include ` `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 << ``"Reversed 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 ` `#include `   `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``(``"Reversed 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(``"Given linked list "``);` `        ``list.printList(head);` `        ``Node res = list.reverseUtil(head, ``null``);` `        ``System.out.println(``"\nReversed linked list "``);` `        ``list.printList(res);` `    ``}` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# 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):` `            ``print` `(temp.data, end``=``" "``)` `            ``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``)`   `print` `(``"Given linked list"``)` `llist.printList()`   `llist.reverse()`   `print` `(``"\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;`   `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(``"Given linked list "``);` `        ``list.printList(list.head);` `        ``Node res = list.reverseUtil(list.head, ``null``);` `        ``Console.WriteLine(``"\nReversed linked list "``);` `        ``list.printList(res);` `    ``}` `}`   `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output

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

Time Complexity: O(N), Visiting every node of the linked list of size N.
Auxiliary Space: O(N), Function call stack space

## Reverse a linked list using Stack:

The idea is to store the all the nodes in the stack then make a reverse linked list.

Follow the steps below to solve the problem:

• 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 ` `#include ` `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 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 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 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 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)`

## 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``))))` `    ``print``(``"Given linked list"``)` `    ``temp ``=` `head` `    ``while` `temp:` `        ``print``(temp.val, end``=``' '``)` `        ``temp ``=` `temp.``next` `    ``obj ``=` `Solution()` `    ``print``(``"\nReversed linked list"``)` `    ``head ``=` `obj.reverseLLUsingStack(head)` `    ``while` `head:` `        ``print``(head.val, end``=``' '``)` `        ``head ``=` `head.``next`

## 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 s = ``new` `Stack();` `        ``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`

## Javascript

 ``

Output

```Given linked list
1 2 3 4