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

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.