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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.