Skip to content
Related Articles

Related Articles

Improve Article

Program to reverse a linked list using Stack

  • Difficulty Level : Medium
  • Last Updated : 21 Jun, 2021

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 <bits/stdc++.h>
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<Node *> 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<Node > stk = new Stack<Node> ();
 
    // 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<Node > stk = new Stack<Node> ();
 
    // 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




<script>
 
      // JavaScript program to reverse linked list
      // using stack
      /* Link list node */
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
        }
      }
      var 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. */
      function push(new_data) {
        var new_node = new Node();
 
        new_node.data = new_data;
        new_node.next = head;
        head = new_node;
      }
 
      // Function to reverse linked list
      function reverseList(head) {
        // Stack to store elements of list
        var stk = [];
 
        // Push the elements of list to stack
        var ptr = head;
        while (ptr.next != null) {
          stk.push(ptr);
          ptr = ptr.next;
        }
 
        // Pop from stack and replace
        // current nodes value'
        head = ptr;
        while (stk.length != 0) {
          ptr.next = stk[stk.length - 1];
          ptr = ptr.next;
          stk.pop();
        }
        ptr.next = null;
 
        return head;
      }
 
      // Function to print the Linked list
      function printList(head) {
        while (head != null) {
          document.write(head.data + " ");
          head = head.next;
        }
      }
 
      // Driver Code
      /* 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);
       
</script>
Output: 



5 4 3 2 1

 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :