# Program to reverse a linked list using Stack

Last Updated : 11 Jan, 2023

Given a linked list. The task is to reverse the order of the elements of the Linked List using an auxiliary Stack.

Examples:

```Input : List = 3 -> 2 -> 1
Output : 1 -> 2 -> 3

Input : 9 -> 7 -> 4 -> 2
Output : 2 -> 4 -> 7 -> 9 ```

Algorithm

1. Traverse the list and push all of its nodes onto a stack.
2. Traverse the list from the head node again and pop a value from the stack top and connect them in reverse order.

Below is the implementation of the above approach:

## C++

 `// C/C++ program to reverse linked list ` `// using stack ` ` `  `#include ` `using` `namespace` `std; ` ` `  `/* Link list node */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `/* Given a reference (pointer to pointer) to ` `   ``the head of a list and an int, push a new  ` `   ``node on the front of the list. */` `void` `push(``struct` `Node** head_ref, ``int` `new_data) ` `{ ` `    ``struct` `Node* new_node = ``new` `Node; ` ` `  `    ``new_node->data = new_data; ` `    ``new_node->next = (*head_ref); ` `    ``(*head_ref) = new_node; ` `} ` ` `  `// Function to reverse linked list ` `Node *reverseList(Node* head) ` `{ ` `    ``// Stack to store elements of list ` `    ``stack stk; ` ` `  `    ``// Push the elements of list to stack ` `    ``Node* ptr = head; ` `    ``while` `(ptr->next != NULL) { ` `        ``stk.push(ptr); ` `        ``ptr = ptr->next; ` `    ``} ` ` `  `    ``// Pop from stack and replace ` `    ``// current nodes value' ` `    ``head = ptr; ` `    ``while` `(!stk.empty()) { ` `        ``ptr->next = stk.top(); ` ` `  `        ``ptr = ptr->next; ` `        ``stk.pop(); ` `    ``} ` `     `  `    ``ptr->next = NULL; ` `     `  `    ``return` `head; ` `} ` ` `  `// Function to print the Linked list ` `void` `printList(Node* head) ` `{ ` `    ``while` `(head) { ` `        ``cout << head->data << ``" "``; ` `        ``head = head->next; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL; ` ` `  `    ``/* Use push() to construct below list  ` `    ``1->2->3->4->5 */` `    ``push(&head, 5); ` `    ``push(&head, 4); ` `    ``push(&head, 3); ` `    ``push(&head, 2); ` `    ``push(&head, 1); ` ` `  `    ``head = reverseList(head); ` ` `  `    ``printList(head); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to reverse linked list  ` `// using stack  ` `import` `java.util.*; ` `class` `GfG  ` `{  ` ` `  `/* Link list node */` `static` `class` `Node ` `{  ` `    ``int` `data;  ` `    ``Node next;  ` `} ` `static` `Node head = ``null``; ` ` `  `/* Given a reference (pointer to pointer) to  ` `the head of a list and an int, push a new  ` `node on the front of the list. */` `static` `void` `push( ``int` `new_data)  ` `{  ` `    ``Node new_node = ``new` `Node();  ` ` `  `    ``new_node.data = new_data;  ` `    ``new_node.next = (head);  ` `    ``(head) = new_node;  ` `}  ` ` `  `// Function to reverse linked list  ` `static` `Node reverseList(Node head)  ` `{  ` `    ``// Stack to store elements of list  ` `    ``Stack stk = ``new` `Stack ();  ` ` `  `    ``// Push the elements of list to stack  ` `    ``Node ptr = head;  ` `    ``while` `(ptr.next != ``null``)  ` `    ``{  ` `        ``stk.push(ptr);  ` `        ``ptr = ptr.next;  ` `    ``}  ` ` `  `    ``// Pop from stack and replace  ` `    ``// current nodes value'  ` `    ``head = ptr;  ` `    ``while` `(!stk.isEmpty()) ` `    ``{  ` `        ``ptr.next = stk.peek();  ` `        ``ptr = ptr.next;  ` `        ``stk.pop();  ` `    ``}  ` `    ``ptr.next = ``null``;  ` `     `  `    ``return` `head;  ` `}  ` ` `  `// Function to print the Linked list  ` `static` `void` `printList(Node head)  ` `{  ` `    ``while` `(head != ``null``)  ` `    ``{  ` `        ``System.out.print(head.data + ``" "``);  ` `        ``head = head.next;  ` `    ``}  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``/* Start with the empty list */` `    ``//Node head = null;  ` ` `  `    ``/* Use push() to construct below list  ` `    ``1->2->3->4->5 */` `    ``push( ``5``);  ` `    ``push( ``4``);  ` `    ``push( ``3``);  ` `    ``push( ``2``);  ` `    ``push( ``1``);  ` ` `  `    ``head = reverseList(head);  ` ` `  `    ``printList(head);  ` `} ` `}  ` ` `  `// This code is contributed by Prerna Saini. `

## Python3

 `# Python3 program to reverse a linked ` `# list using stack  ` ` `  `# Link list node  ` `class` `Node: ` `     `  `    ``def` `__init__(``self``, data, ``next``): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `next` ` `  `class` `LinkedList: ` `     `  `    ``def` `__init__(``self``): ` `        ``self``.head ``=` `None` `         `  `    ``# Function to push a new Node in  ` `    ``# the linked list  ` `    ``def` `push(``self``, new_data):  ` `     `  `        ``new_node ``=` `Node(new_data, ``self``.head)  ` `        ``self``.head ``=` `new_node ` `     `  `    ``# Function to reverse linked list  ` `    ``def` `reverseList(``self``):  ` `     `  `        ``# Stack to store elements of list  ` `        ``stk ``=` `[] ` `     `  `        ``# Push the elements of list to stack  ` `        ``ptr ``=` `self``.head  ` `        ``while` `ptr.``next` `!``=` `None``:  ` `            ``stk.append(ptr)  ` `            ``ptr ``=` `ptr.``next` `     `  `        ``# Pop from stack and replace  ` `        ``# current nodes value'  ` `        ``self``.head ``=` `ptr  ` `        ``while` `len``(stk) !``=` `0``:  ` `            ``ptr.``next` `=` `stk.pop()  ` `            ``ptr ``=` `ptr.``next` `         `  `        ``ptr.``next` `=` `None` `     `  `    ``# Function to print the Linked list  ` `    ``def` `printList(``self``): ` `         `  `        ``curr ``=` `self``.head ` `        ``while` `curr:  ` `            ``print``(curr.data, end ``=` `" "``)  ` `            ``curr ``=` `curr.``next` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``# Start with the empty list ` `    ``linkedList ``=` `LinkedList()  ` ` `  `    ``# Use push() to construct below list  ` `    ``# 1.2.3.4.5 ` `    ``linkedList.push(``5``)  ` `    ``linkedList.push(``4``)  ` `    ``linkedList.push(``3``)  ` `    ``linkedList.push(``2``)  ` `    ``linkedList.push(``1``)  ` ` `  `    ``linkedList.reverseList()  ` ` `  `    ``linkedList.printList()  ` ` `  `# This code is contributed by Rituraj Jain  `

## C#

 `// C# program to reverse linked list  ` `// using stack  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GfG  ` `{  ` ` `  `/* Link list node */` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node next;  ` `}  ` `static` `Node head = ``null``;  ` ` `  `/* Given a reference (pointer to pointer) to  ` `the head of a list and an int, push a new  ` `node on the front of the list. */` `static` `void` `push( ``int` `new_data)  ` `{  ` `    ``Node new_node = ``new` `Node();  ` ` `  `    ``new_node.data = new_data;  ` `    ``new_node.next = (head);  ` `    ``(head) = new_node;  ` `}  ` ` `  `// Function to reverse linked list  ` `static` `Node reverseList(Node head)  ` `{  ` `    ``// Stack to store elements of list  ` `    ``Stack stk = ``new` `Stack ();  ` ` `  `    ``// Push the elements of list to stack  ` `    ``Node ptr = head;  ` `    ``while` `(ptr.next != ``null``)  ` `    ``{  ` `        ``stk.Push(ptr);  ` `        ``ptr = ptr.next;  ` `    ``}  ` ` `  `    ``// Pop from stack and replace  ` `    ``// current nodes value'  ` `    ``head = ptr;  ` `    ``while` `(stk.Count != 0) ` `    ``{  ` `        ``ptr.next = stk.Peek();  ` `        ``ptr = ptr.next;  ` `        ``stk.Pop();  ` `    ``}  ` `    ``ptr.next = ``null``;  ` `     `  `    ``return` `head;  ` `}  ` ` `  `// Function to print the Linked list  ` `static` `void` `printList(Node head)  ` `{  ` `    ``while` `(head != ``null``)  ` `    ``{  ` `        ``Console.Write(head.data + ``" "``);  ` `        ``head = head.next;  ` `    ``}  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main(String[] args)  ` `{  ` `    ``/* Start with the empty list */` `    ``//Node head = null;  ` ` `  `    ``/* Use push() to construct below list  ` `    ``1->2->3->4->5 */` `    ``push( 5);  ` `    ``push( 4);  ` `    ``push( 3);  ` `    ``push( 2);  ` `    ``push( 1);  ` ` `  `    ``head = reverseList(head);  ` ` `  `    ``printList(head);  ` `}  ` `} ` ` `  `// This code contributed by Rajput-Ji `

## Javascript

 ``

Output

`5 4 3 2 1 `

Complexity Analysis:

• Time Complexity : O(n), as we are traversing over the linked list of size N using a while loop.
• Auxiliary Space: O(N), as we are using stack of size N in worst case which is extra space.

We can reverse a linked list with O(1) auxiliary space. See more methods to reverse a linked list.

Previous
Next