# Program to reverse a linked list using Stack

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.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next