Reverse a Linked List

Last Updated : 18 Feb, 2025

Given a linked list, the task is to reverse the linked list by changing the links between nodes.

Examples:

Input: head: 1 -> 2 -> 3 -> 4 -> NULL
Output: head: 4 -> 3 -> 2 -> 1 -> NULL
Explanation: Reversed Linked List:

Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> NULL
Output: head: 5 -> 4 -> 3 -> 2 -> 1 -> NULL
Explanation: Reversed Linked List:

Table of Content

[Expected Approach] Using Iterative Method - O(n) Time and O(1) Space

The idea is to reverse the links of all nodes using three pointers:
prev: pointer to keep track of the previous node
curr: pointer to keep track of the current node
next: pointer to keep track of the next node
Starting from the first node, initialize curr with the head of linked list and next with the next node of curr. Update the next pointer of curr with prev. Finally, move the three pointer by updating prev with curr and curr with next.

Follow the steps below to solve the problem:

Initialize three pointers prev as NULL, curr as head, and next as NULL.
Iterate through the linked list. In a loop, do the following:
- Store the next node, next = curr -> next
- Update the next pointer of curr to prev, curr -> next = prev
- Update prev as curr and curr as next, prev = curr and curr = next

C++

// Iterative C++ program to reverse a linked list

#include <iostream>
using namespace std;

class Node {
  public:
    int data;
    Node *next;

    Node(int new_data) {
        data = new_data;
        next = nullptr;
    }
};

// Given the head of a list, reverse the list and 
// return the head of reversed list
Node *reverseList(Node *head) {

    // Initialize three pointers: curr, prev and next
    Node *curr = head, *prev = nullptr, *next;

    // Traverse all the nodes of Linked List
    while (curr != nullptr) {

        // Store next
        next = curr->next;

        // Reverse current node's next pointer
        curr->next = prev;

        // Move pointers one position ahead
        prev = curr;
        curr = next;
    }

    // Return the head of reversed linked list
    return prev;
}

void printList(Node *node) {
    while (node != nullptr) {
        cout << " " << node->data;
        node = node->next;
    }
}

int main() {

    // Create a hard-coded linked list:
    // 1 -> 2 -> 3 -> 4 -> 5
    Node *head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);

    cout << "Given Linked list:";
    printList(head);

    head = reverseList(head);

    cout << "\nReversed Linked List:";
    printList(head);

    return 0;
}

// Iterative C program to reverse a linked list

#include <stdio.h>

struct Node {
    int data;
    struct Node* next;
};

// Given the head of a list, reverse the list and return the
// head of reversed list
struct Node* reverseList(struct Node* head) {

    // Initialize three pointers: curr, prev and next
    struct Node *curr = head, *prev = NULL, *next;

    // Traverse all the nodes of Linked List
    while (curr != NULL) {

        // Store next
        next = curr->next;

        // Reverse current node's next pointer
        curr->next = prev;

        // Move pointers one position ahead
        prev = curr;
        curr = next;
    }

    // Return the head of reversed linked list
    return prev;
}

void printList(struct Node* node) {
    while (node != NULL) {
        printf(" %d", node->data);
        node = node->next;
    }
}


struct Node* createNode(int new_data) {
    struct Node* new_node
        = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;
    return new_node;
}

int main() {

    // Create a hard-coded linked list:
    // 1 -> 2 -> 3 -> 4 -> 5
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    printf("Given Linked list:");
    printList(head);

    head = reverseList(head);

    printf("\nReversed Linked List:");
    printList(head);

    return 0;
}

Java

// Iterative Java program to reverse a linked list

class Node {
    int data;
    Node next;

    Node(int new_data) {
        data = new_data;
        next = null;
    }
}

// Given the head of a list, reverse the list and return the
// head of reversed list
class GfG {
     static Node reverseList(Node head) {
        
        // Initialize three pointers: curr, prev and next
        Node curr = head, prev = null, next;

        // Traverse all the nodes of Linked List
        while (curr != null) {
            
            // Store next
            next = curr.next;
            
            // Reverse current node's next pointer
            curr.next = prev;
            
            // Move pointers one position ahead
            prev = curr;
            curr = next;
        }
        
        // Return the head of reversed linked list
        return prev;
    }

    // This function prints the contents
    // of the linked list starting from the head
    static void printList(Node node) {
        while (node != null) {
            System.out.print(" " + node.data);
            node = node.next;
        }
    }

    public static void main(String[] args) {

        // Create a hard-coded linked list:
        // 1 -> 2 -> 3 -> 4 -> 5
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);

        System.out.print("Given Linked list:");
        printList(head);
        
        head = reverseList(head);

        System.out.print("\nReversed Linked List:");
        printList(head);
    }
}

Python

# Iterative Python program to reverse a linked list
class Node:
    def __init__(self, newData):
        self.data = newData
        self.next = None

# Given the head of a list, reverse the list and return the
# head of reversed list
def reverseList(head):

    # Initialize three pointers: curr, prev and next
    curr = head
    prev = None

    # Traverse all the nodes of Linked List
    while curr is not None:

        # Store next
        nextNode = curr.next

        # Reverse current node's next pointer
        curr.next = prev

        # Move pointers one position ahead
        prev = curr
        curr = nextNode

    # Return the head of reversed linked list
    return prev

def printList(node):
    while node is not None:
        print(f" {node.data}", end="")
        node = node.next
    print()

if __name__ == "__main__":

    # Create a hard-coded linked list:
    # 1 -> 2 -> 3 -> 4 -> 5
    head = Node(1)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(4)
    head.next.next.next.next = Node(5)

    print("Given Linked list:", end="")
    printList(head)

    head = reverseList(head)

    print("Reversed Linked List:", end="")
    printList(head)

// Iterative C# program to reverse a linked list
using System;

class Node {
    public int Data;
    public Node Next;

    public Node(int newData) {
        Data = newData;
        Next = null;
    }
}

// Given the head of a list, reverse the list and return the
// head of reversed list
class GfG {
    static Node ReverseList(Node head) {
      
        // Initialize three pointers: curr, prev and next
        Node curr = head;
        Node prev = null;
        Node next;

        // Traverse all the nodes of Linked List
        while (curr != null) {
          
            // Store next
            next = curr.Next;

            // Reverse current node's next pointer
            curr.Next = prev;

            // Move pointers one position ahead
            prev = curr;
            curr = next;
        }

        // Return the head of reversed linked list
        return prev;
    }

    static void PrintList(Node node) {
        while (node != null) {
            Console.Write(" " + node.Data);
            node = node.Next;
        }
        Console.WriteLine();
    }

    static void Main() {
     	
        // Create a hard-coded linked list:
        // 1 -> 2 -> 3 -> 4 -> 5
        Node head = new Node(1);
        head.Next = new Node(2);
        head.Next.Next = new Node(3);
        head.Next.Next.Next = new Node(4);
        head.Next.Next.Next.Next = new Node(5);

        Console.Write("Given Linked list:");
        PrintList(head);

        head = ReverseList(head);

        Console.Write("Reversed Linked List:");
        PrintList(head);
    }
}

JavaScript

// Iterative JavaScript program to reverse a linked list

class Node {
    constructor(newData) {
        this.data = newData;
        this.next = null;
    }
}

// Given the head of a list, reverse the list and return the
// head of reversed list
function reverseList(head) {

    // Initialize three pointers: curr, prev and next
    let curr = head;
    let prev = null;
    let next;

    // Traverse all the nodes of Linked List
    while (curr !== null) {
        // Store next
        next = curr.next;

        // Reverse current node's next pointer
        curr.next = prev;

        // Move pointers one position ahead
        prev = curr;
        curr = next;
    }

    // Return the head of reversed linked list
    return prev;
}

function printList(node) {
    while (node !== null) {
        console.log(" " + node.data);
        node = node.next;
    }
    console.log();
}

// Driver Code
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

console.log("Given Linked list:");
printList(head);

head = reverseList(head);

console.log("Reversed Linked List:");
printList(head);

Output

Given Linked list: 1 2 3 4 5
Reversed Linked List: 5 4 3 2 1

[Alternate Approach - 1] Using Recursion - O(n) Time and O(n) Space

The idea is to reach the last node of the linked list using recursion then start reversing the linked list from the last node.

Follow the steps below to solve the problem:

Divide the list in two parts - first node and rest of the linked list.
Call reverse for the rest of the linked list.
Link the rest linked list to first.
Fix head pointer to NULL.

C++

// Recursive C++ program to reverse a linked list

#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    int data;
    Node *next;

    Node(int new_data) {
        data = new_data;
        next = nullptr;
    }
};

// Given the head of a list, reverse the list
// and return the head of reversed list
Node *reverseList(Node *head) {
    if (head == NULL || head->next == NULL)
        return head;

    // reverse the rest of linked list and put
    //  the first element at the end
    Node *rest = reverseList(head->next);

    // Make the current head as last node of
    // remaining linked list
    head->next->next = head;

    // Update next of current head to NULL
    head->next = NULL;

    // Return the reversed linked list
    return rest;
}

void printList(Node *node) {
    while (node != nullptr) {
        cout << " " << node->data;
        node = node->next;
    }
}

int main() {

    // Create a hard-coded linked list:
    // 1 -> 2 -> 3 -> 4 -> 5
    Node *head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);

    cout << "Given Linked List:";
    printList(head);

    head = reverseList(head);

    cout << "\nReversed Linked List:";
    printList(head);

    return 0;
}

// Recursive C program to reverse a linked list
#include <stdio.h>

struct Node {
    int data;
    struct Node* next;
};

// Given the head of a list, reverse the list and 
// return the head of reversed list
struct Node* reverseList(struct Node* head) {
    if (head == NULL || head->next == NULL)
        return head;

    // reverse the rest of linked list and put 
	// the first element at the end
    struct Node* rest = reverseList(head->next);

    // Make the current head as last node of 
	// remaining linked list
    head->next->next = head;

    // Update next of current head to NULL
    head->next = NULL;

    // Return the reversed linked list
    return rest;
}


// This function prints the contents
// of the linked list starting from the head
void printList(struct Node* node) {
    while (node != NULL) {
        printf(" %d", node->data);
        node = node->next;
    }
    printf("\n");
}

struct Node* createNode(int new_data) {
    struct Node* new_node = 
       (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;
    return new_node;
}

int main() {
  
    // Create a hard-coded linked list:
    // 1 -> 2 -> 3 -> 4 -> 5
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    printf("Given Linked List:");
    printList(head);

    head = reverseList(head);

    printf("Reversed Linked List:");
    printList(head);

    return 0;
}

Java

// Recursive Java program to reverse a linked list

class Node {
    int data;
    Node next;

    Node(int new_data) {
        data = new_data;
        next = null;
    }
}

class GfG {
    // Given the head of a list, reverse the list 
    // and return the head of reversed list
    static Node reverseList(Node head) {

        // If we have reached last node or linked
        // list is empty, return head of linked list
        if (head == null || head.next == null)
            return head;

        // reverse the rest of linked list and put 
        // the first element at the end
        Node rest = reverseList(head.next);

        // Make the current head as last node of 
        // remaining linked list
        head.next.next = head;

        // Update next of current head to NULL
        head.next = null;

        // Return the reversed linked list
        return rest;
    }

    // This function prints the contents
    // of the linked list starting from the head
    static void printList(Node node) {
        while (node != null) {
            System.out.print(" " + node.data);
            node = node.next;
        }
    }

    public static void main(String[] args)
    {

        // Create a hard-coded linked list:
        // 1 -> 2 -> 3 -> 4 -> 5
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);

        System.out.print("Given Linked List:");
        printList(head);

        head = reverseList(head);

        System.out.print("\nReversed Linked List:");
        printList(head);
    }
}

Python

# Recursive Python program to reverse a linked list

class Node:
    def __init__(self, newData):
        self.data = newData
        self.next = None

# Given the head of a list, reverse the list and 
# return the head of reversed list
def reverseList(head):
    if head is None or head.next is None:
        return head

    # reverse the rest of linked list and put the 
    # first element at the end
    rest = reverseList(head.next)

    # Make the current head as last node of 
    # remaining linked list
    head.next.next = head

    # Update next of current head to NULL
    head.next = None

    # Return the reversed linked list
    return rest

def printList(node):
    while node is not None:
        print(f" {node.data}", end='')
        node = node.next
    print()


if __name__ == "__main__":

    # Create a hard-coded linked list:
    # 1 -> 2 -> 3 -> 4 -> 5
    head = Node(1)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(4)
    head.next.next.next.next = Node(5)

    print("Given Linked List:", end='')
    printList(head)

    head = reverseList(head)

    print("\nReversed Linked List:", end='')
    printList(head)

// Recursive C# program to reverse a linked list

using System;

class Node {
    public int Data;
    public Node Next;

    public Node(int newData) {
        Data = newData;
        Next = null;
    }
}

class GfG {
  	// Given the head of a list, reverse the list 
	// and return the head of reversed list
    static Node ReverseList(Node head) {
        if (head == null || head.Next == null)
            return head;

        // reverse the rest of linked list and 
        // put the first element at the end
        Node rest = ReverseList(head.Next);

        // Make the current head as last node 
        // of remaining linked list
        head.Next.Next = head;

        // Update next of current head to NULL
        head.Next = null;

        // Return the reversed linked list
        return rest;
    }

    // This function prints the contents
    // of the linked list starting from the head
    static void PrintList(Node node) {
        while (node != null) {
            Console.Write(" " + node.Data);
            node = node.Next;
        }
      	Console.WriteLine();
    }
  
    static void Main() {
      
        // Create a hard-coded linked list:
        // 1 -> 2 -> 3 -> 4 -> 5
        Node head = new Node(1);
        head.Next = new Node(2);
        head.Next.Next = new Node(3);
        head.Next.Next.Next = new Node(4);
        head.Next.Next.Next.Next = new Node(5);

        Console.Write("Given Linked List:");
        PrintList(head);

        head = ReverseList(head);

        Console.Write("\nReversed Linked List:");
		PrintList(head);
    }
}

JavaScript

// Recursive javascript program to reverse a linked list

class Node {
    constructor(new_data) {
        this.data = new_data;
        this.next = null;
    }
}

// Given the head of a list, reverse the list 
// and return the head of reversed list
function reverseList(head) {
    if (head === null || head.next === null)
        return head;

    // reverse the rest of linked list and 
    // put the first element at the end
    let rest = reverseList(head.next);

    // Make the current head as last node of 
    // remaining linked list
    head.next.next = head;

    // Update next of current head to NULL
    head.next = null;

    // Return the reversed linked list
    return rest;
}

function printList(node) {
    while (node !== null) {
        console.log(` ${node.data}`);
        node = node.next;
    }
    console.log();
}

// Driver Code
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

console.log("Given Linked List:");
printList(head);

head = reverseList(head);

console.log("\nReversed Linked List:");
printList(head);

Output

Given Linked List: 1 2 3 4 5
Reversed Linked List: 5 4 3 2 1

[Alternate Approach - 2] Using Stack - O(n) Time and O(n) Space

The idea is to traverse the linked list and push all nodes except the last node into the stack. Make the last node as the new head of the reversed linked list. Now, start popping the element and append each node to the reversed Linked List. Finally, return the head of the reversed linked list.

Follow the steps below to solve the problem:

Push all the nodes(values and address) except the last node in the stack.
Once the nodes are pushed, update the Head pointer to the last node.
Start popping the nodes and push them at the end of the linked list in the same order until the stack is empty.
Update the next pointer of last node in the stack by NULL.

C++

// C++ program to reverse linked list using Stack

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* next;

    Node(int new_data) {
        data = new_data;
        next = nullptr;
    }
};

// Function to reverse the linked list
Node* reverseList(Node* head) {
  	
    // Create a stack to store the nodes
    stack<Node*> s;
  
    Node* temp = head;
  
  	// Push all nodes except the last node into stack
    while (temp->next != NULL) {
        s.push(temp);
        temp = temp->next;
    }
  	
  	// Make the last node as new head of the linked list
    head = temp;
  
  	// Pop all the nodes and append to the linked list
    while (!s.empty()) {
      	
        // append the top value of stack in list
        temp->next = s.top();
        
      	// Pop the value from stack
        s.pop();
        
      	// move to the next node in the list
        temp = temp->next;
    }
  	
  	// Update the next pointer of last node of stack to NULL
    temp->next = NULL;
  
  	return head;
}

void printList(Node* node) {
    while (node != nullptr) {
        cout << " " << node->data;
        node = node->next;
    }
}

int main() {
  	
    // Create a hard-coded linked list:
    // 1 -> 2 -> 3 -> 4 -> 5
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);

    cout << "Given Linked List:";
    printList(head);

    head = reverseList(head);

    cout << "\nReversed Linked List:";
    printList(head);
  
  	return 0;
}

// C program to reverse linked list using Stack

#include <stdio.h>

struct Node {
    int data;
    struct Node* next;
};


// Function to create a new node
struct Node* createNode(int new_data) {
    struct Node* new_node = 
       (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;
    return new_node;
}

// Function to reverse the linked list
struct Node* reverseList(struct Node* head) {
  
    // Create a stack to store the nodes
    struct Node* stack[100000];
    int top = -1;
    
    struct Node* temp = head;
    
    // Push all nodes except the last node into stack
    while (temp != NULL) {
        stack[++top] = temp;
        temp = temp->next;
    }
    
    // Make the last node as new head of the linked list
    if (top >= 0) {
        head = stack[top];
        temp = head;
        
        // Pop all the nodes and append to the linked list
        while (top > 0) {
          	
          	// append the top value of stack in list and 
          	// pop the top value by decrementing top by 1
            temp->next = stack[--top];
          
          	// move to the next node in the list
            temp = temp->next;
        }
        
        // Update the next pointer of last node of stack to NULL
        temp->next = NULL;
    }
    
    return head;
}


void printList(struct Node* node) {
    while (node != NULL) {
        printf(" %d", node->data);
        node = node->next;
    }
    printf("\n");
}


int main() {
  	
    // Create a hard-coded linked list:
    // 1 -> 2 -> 3 -> 4 -> 5
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    printf("Given Linked List:");
    printList(head);

    head = reverseList(head);

    printf("\nReversed Linked List:");
    printList(head);

    return 0;
}

Java

// Java program to reverse linked list using Stack

import java.util.Stack;

class Node {
    int data;
    Node next;

    Node(int new_data) {
        data = new_data;
        next = null;
    }
}

class GfG {
  	
    // Function to reverse the linked list
    static Node reverseList(Node head) {
      	
        // Create a stack to store the nodes
        Stack<Node> stack = new Stack<>();

        Node temp = head;

        // Push all nodes except the last node into stack
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }

        // Make the last node as new head of the linked list
        if (!stack.isEmpty()) {
            head = stack.pop();
            temp = head;

            // Pop all the nodes and append to the linked list
            while (!stack.isEmpty()) {
              
                // append the top value of stack in list
                temp.next = stack.pop();
                
              	// move to the next node in the list
                temp = temp.next;
            }

            // Update the next pointer of last node 
          	// of stack to NULL
            temp.next = null;
        }

        return head;
    }

    // This function prints the contents 
    // of the linked list starting from the head
    static void printList(Node node) {
        while (node != null) {
            System.out.print(" " + node.data);
            node = node.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
      	
        // Create a hard-coded linked list:
        // 1 -> 2 -> 3 -> 4 -> 5
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);

        System.out.print("Given Linked List:");
        printList(head);

        head = reverseList(head);

        System.out.print("\nReversed Linked List:");
        printList(head);
    }
}

Python

# Python program to reverse linked list using Stack

class Node:
    def __init__(self, new_data):
      	
        self.data = new_data
        self.next = None

def reverseList(head):
  	
    # Create a stack to store the nodes
    stack = []
  
    temp = head
  
    # Push all nodes except the last node into stack
    while temp.next is not None:
        stack.append(temp)
        temp = temp.next
  
    # Make the last node as new head of the linked list
    head = temp
  
    # Pop all the nodes and append to the linked list
    while stack:
      	
        # append the top value of stack in list
        temp.next = stack.pop()
        
        # move to the next node in the list
        temp = temp.next
  
    # Update the next pointer of last node 
    # of stack to None
    temp.next = None
  
    return head

def printList(node):
    while node is not None:
        print(f" {node.data}", end="")
        node = node.next
    print()


# Create a hard-coded linked list:
# 1 -> 2 -> 3 -> 4 -> 5
head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)
head.next.next.next.next = Node(5)

print("Given Linked List:", end="")
printList(head)

head = reverseList(head)

print("Reversed Linked List:", end="")
printList(head)

// C# program to reverse linked list using stack

using System;
using System.Collections.Generic;

class Node {
    public int Data;
    public Node Next;

    public Node(int newData) {
        Data = newData;
        Next = null;
    }
}

class GfG {
  	
  	// Function to reverse the linked list
    static Node ReverseList(Node head) {
      	
        // Create a stack to store the nodes
        Stack<Node> stack = new Stack<Node>();

        Node temp = head;

        // Push all nodes except the last node into stack
        while (temp.Next != null) {
            stack.Push(temp);
            temp = temp.Next;
        }

        // Make the last node as new head of the linked list 
        head = temp;

        // Pop all the nodes and append to the linked list
        while (stack.Count > 0) {
          	
            // append the top value of stack in list
            temp.Next = stack.Pop();

            // move to the next node in the list
            temp = temp.Next;
        }

        // Update the next pointer of last node of stack to null
        temp.Next = null;

        return head;
    }

    static void PrintList(Node node) {
        while (node != null) {
            Console.Write(" " + node.Data);
            node = node.Next;
        }
        Console.WriteLine();
    }

    static void Main() {
      	
        // Create a hard-coded linked list:
        // 1 -> 2 -> 3 -> 4 -> 5
        Node head = new Node(1);
        head.Next = new Node(2);
        head.Next.Next = new Node(3);
        head.Next.Next.Next = new Node(4);
        head.Next.Next.Next.Next = new Node(5);

        Console.Write("Given Linked List:");
        PrintList(head);

        head = ReverseList(head);

        Console.Write("\nReversed Linked List:");
        PrintList(head);
    }
}

JavaScript

// JavaScript program to reverse linked list using Stack

class Node {
	
    constructor(newData) {
        this.data = newData;
        this.next = null;
    }
}

// Function to reverse the linked list
function reverseList(head) {
	
    // Create a stack to store the nodes
    let stack = [];
    
    let temp = head;

    // Push all nodes except the last node into stack
    while (temp.next !== null) {
        stack.push(temp);
        temp = temp.next;
    }

    // Make the last node as new head of the Linked List
    head = temp;

    // Pop all the nodes and append to the linked list
    while (stack.length > 0) {
     
        // append the top value of stack in list
        temp.next = stack.pop();

        // move to the next node in the list
        temp = temp.next;
    }

    // Update the next pointer of last node of stack to null
    temp.next = null;

    return head;
}

function printList(node) {
    while (node !== null) {
        console.log(" " + node.data);
        node = node.next;
    }
    console.log();
}


// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

console.log("Given Linked List:");
printList(head);

// Function call to return the reversed list
head = reverseList(head);

console.log("\nReversed Linked List:");
printList(head);

Output

Given Linked List: 1 2 3 4 5
Reversed Linked List: 5 4 3 2 1

Deletion in Linked List

kartik

Improve

Article Tags :

Practice Tags :

Reverse a Linked List

[Expected Approach] Using Iterative Method - O(n) Time and O(1) Space

[Alternate Approach - 1] Using Recursion - O(n) Time and O(n) Space

[Alternate Approach - 2] Using Stack - O(n) Time and O(n) Space

Similar Reads

Types of Linked List

Basic Operations on Linked List

Thank You!

What kind of Experience do you want to share?