Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Reverse a linked list

 

Given pointer to the head node of a linked list, the task is to reverse the linked list. We need to reverse the list by changing the links between nodes.

Examples

Input: Head of following linked list 
1->2->3->4->NULL 
Output: Linked list should be changed to, 
4->3->2->1->NULL

Input: Head of following linked list 
1->2->3->4->5->NULL 
Output: Linked list should be changed to, 
5->4->3->2->1->NULL

Input: NULL 
Output: NULL

Input: 1->NULL 
Output: 1->NULL 
 

Iterative Method 

  1. Initialize three pointers prev as NULL, curr as head and next as NULL.
  2. Iterate through the linked list. In loop, do following. 
    // Before changing next of current, 
    // store next node 
    next = curr->next
    // Now change next of current 
    // This is where actual reversing happens 
    curr->next = prev 
    // Move prev and curr one step forward 
    prev = curr 
    curr = next

Below is the implementation of the above approach: 

C++




// Iterative C++ program to reverse
// a linked list
#include <iostream>
using namespace std;
  
/* Link list node */
struct Node {
    int data;
    struct Node* next;
    Node(int data)
    {
        this->data = data;
        next = NULL;
    }
};
  
struct LinkedList {
    Node* head;
    LinkedList() { head = NULL; }
  
    /* Function to reverse the linked list */
    void reverse()
    {
        // Initialize current, previous and
        // next pointers
        Node* current = head;
        Node *prev = NULL, *next = NULL;
  
        while (current != NULL) {
            // Store next
            next = current->next;
  
            // Reverse current node's pointer
            current->next = prev;
  
            // Move pointers one position ahead.
            prev = current;
            current = next;
        }
        head = prev;
    }
  
    /* Function to print linked list */
    void print()
    {
        struct Node* temp = head;
        while (temp != NULL) {
            cout << temp->data << " ";
            temp = temp->next;
        }
    }
  
    void push(int data)
    {
        Node* temp = new Node(data);
        temp->next = head;
        head = temp;
    }
};
  
/* Driver code*/
int main()
{
    /* Start with the empty list */
    LinkedList ll;
    ll.push(20);
    ll.push(4);
    ll.push(15);
    ll.push(85);
  
    cout << "Given linked list\n";
    ll.print();
  
    ll.reverse();
  
    cout << "\nReversed Linked list \n";
    ll.print();
    return 0;
}


C




// Iterative C program to reverse a linked list
#include <stdio.h>
#include <stdlib.h>
  
/* Link list node */
struct Node {
    int data;
    struct Node* next;
};
  
/* Function to reverse the linked list */
static void reverse(struct Node** head_ref)
{
    struct Node* prev = NULL;
    struct Node* current = *head_ref;
    struct Node* next = NULL;
    while (current != NULL) {
        // Store next
        next = current->next;
  
        // Reverse current node's pointer
        current->next = prev;
  
        // Move pointers one position ahead.
        prev = current;
        current = next;
    }
    *head_ref = prev;
}
  
/* Function to push a node */
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node
        = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
  
/* Function to print linked list */
void printList(struct Node* head)
{
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d  ", temp->data);
        temp = temp->next;
    }
}
  
/* Driver code*/
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
  
    push(&head, 20);
    push(&head, 4);
    push(&head, 15);
    push(&head, 85);
  
    printf("Given linked list\n");
    printList(head);
    reverse(&head);
    printf("\nReversed Linked list \n");
    printList(head);
    getchar();
}


Java




// Java program for reversing the linked list
  
class LinkedList {
  
    static Node head;
  
    static class Node {
  
        int data;
        Node next;
  
        Node(int d)
        {
            data = d;
            next = null;
        }
    }
  
    /* Function to reverse the linked list */
    Node reverse(Node node)
    {
        Node prev = null;
        Node current = node;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        node = prev;
        return node;
    }
  
    // prints content of double linked list
    void printList(Node node)
    {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
        list.head = new Node(85);
        list.head.next = new Node(15);
        list.head.next.next = new Node(4);
        list.head.next.next.next = new Node(20);
  
        System.out.println("Given Linked list");
        list.printList(head);
        head = list.reverse(head);
        System.out.println("");
        System.out.println("Reversed linked list ");
        list.printList(head);
    }
}
  
// This code has been contributed by Mayank Jaiswal


Python




# Python program to reverse a linked list
# Time Complexity : O(n)
# Space Complexity : O(1)
  
# Node class
  
  
class Node:
  
    # Constructor to initialize the node object
    def __init__(self, data):
        self.data = data
        self.next = None
  
  
class LinkedList:
  
    # Function to initialize head
    def __init__(self):
        self.head = None
  
    # Function to reverse the linked list
    def reverse(self):
        prev = None
        current = self.head
        while(current is not None):
            next = current.next
            current.next = prev
            prev = current
            current = next
        self.head = prev
  
    # Function to insert a new node at the beginning
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node
  
    # Utility function to print the linked LinkedList
    def printList(self):
        temp = self.head
        while(temp):
            print temp.data,
            temp = temp.next
  
  
# Driver code
llist = LinkedList()
llist.push(20)
llist.push(4)
llist.push(15)
llist.push(85)
  
print "Given Linked List"
llist.printList()
llist.reverse()
print "\nReversed Linked List"
llist.printList()
  
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)


C#




// C# program for reversing the linked list
using System;
  
class GFG {
    
    // Driver Code
    static void Main(string[] args)
    {
        LinkedList list = new LinkedList();
        list.AddNode(new LinkedList.Node(85));
        list.AddNode(new LinkedList.Node(15));
        list.AddNode(new LinkedList.Node(4));
        list.AddNode(new LinkedList.Node(20));
  
        // List before reversal
        Console.WriteLine("Given linked list:");
        list.PrintList();
  
        // Reverse the list
        list.ReverseList();
  
        // List after reversal
        Console.WriteLine("Reversed linked list:");
        list.PrintList();
    }
}
  
class LinkedList {
    Node head;
  
    public class Node {
        public int data;
        public Node next;
  
        public Node(int d)
        {
            data = d;
            next = null;
        }
    }
  
    // function to add a new node at
    // the end of the list
    public void AddNode(Node node)
    {
        if (head == null)
            head = node;
        else {
            Node temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = node;
        }
    }
  
    // function to reverse the list
    public void ReverseList()
    {
        Node prev = null, current = head, next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        head = prev;
    }
  
    // function to print the list data
    public void PrintList()
    {
        Node current = head;
        while (current != null) {
            Console.Write(current.data + " ");
            current = current.next;
        }
        Console.WriteLine();
    }
}
  
// This code is contributed by Mayank Sharma


Javascript




<script>
  
// JavaScript program for reversing the linked list
  
var head;
  
     class Node {
        constructor(val) {
            this.data = val;
            this.next = null;
        }
    }
  
    /* Function to reverse the linked list */
    function reverse(node) {
    var prev = null;
    var current = node;
    var next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        node = prev;
        return node;
    }
  
    // prints content of double linked list
    function printList(node) {
        while (node != null) {
            document.write(node.data + " ");
            node = node.next;
        }
    }
  
    // Driver Code
      
        head = new Node(85);
        head.next = new Node(15);
        head.next.next = new Node(4);
        head.next.next.next = new Node(20);
  
        document.write("Given Linked list<br/>");
        printList(head);
        head = reverse(head);
        document.write("<br/>");
        document.write("Reversed linked list<br/> ");
        printList(head);
  
// This code is contributed by todaysgaurav
  
</script>


Output: 

Given linked list
85 15 4 20 
Reversed Linked list 
20 4 15 85

Time Complexity: O(n) 
Space Complexity: O(1)
Recursive Method: 

   1) Divide the list in two parts - first node and 
      rest of the linked list.
   2) Call reverse for the rest of the linked list.
   3) Link rest to first.
   4) Fix head pointer

Linked List Rverse

C++




// Recursive C++ program to reverse
// a linked list
#include <iostream>
using namespace std;
  
/* Link list node */
struct Node {
    int data;
    struct Node* next;
    Node(int data)
    {
        this->data = data;
        next = NULL;
    }
};
  
struct LinkedList {
    Node* head;
    LinkedList()
    {
        head = NULL;
    }
  
    Node* reverse(Node* head)
    {
        if (head == NULL || head->next == NULL)
            return head;
  
        /* reverse the rest list and put 
          the first element at the end */
        Node* rest = reverse(head->next);
        head->next->next = head;
  
        /* tricky step -- see the diagram */
        head->next = NULL;
  
        /* fix the head pointer */
        return rest;
    }
  
    /* Function to print linked list */
    void print()
    {
        struct Node* temp = head;
        while (temp != NULL) {
            cout << temp->data << " ";
            temp = temp->next;
        }
    }
  
    void push(int data)
    {
        Node* temp = new Node(data);
        temp->next = head;
        head = temp;
    }
};
  
/* Driver program to test above function*/
int main()
{
    /* Start with the empty list */
    LinkedList ll;
    ll.push(20);
    ll.push(4);
    ll.push(15);
    ll.push(85);
  
    cout << "Given linked list\n";
    ll.print();
  
    ll.head = ll.reverse(ll.head);
  
    cout << "\nReversed Linked list \n";
    ll.print();
    return 0;
}


Java




// Recursive Java program to reverse
// a linked list
class recursion { 
    static Node head; // head of list 
      
    static class Node { 
        int data; 
        Node next; 
        Node(int d) 
        
            data = d; 
            next = null
        
    
  
    static Node reverse(Node head) 
    
        if (head == null || head.next == null
            return head; 
  
        /* reverse the rest list and put 
        the first element at the end */
        Node rest = reverse(head.next); 
        head.next.next = head; 
  
        /* tricky step -- see the diagram */
        head.next = null
  
        /* fix the head pointer */
        return rest; 
    
  
    /* Function to print linked list */
    static void print() 
    
        Node temp = head; 
        while (temp != null) { 
            System.out.print(temp.data + " "); 
            temp = temp.next; 
        
        System.out.println();
    
  
    static void push(int data) 
    
        Node temp = new Node(data); 
        temp.next = head; 
        head = temp; 
    
   
  
/* Driver program to test above function*/
public static void main(String args[]) 
    /* Start with the empty list */
       
    push(20); 
    push(4); 
    push(15); 
    push(85); 
  
    System.out.println("Given linked list"); 
    print(); 
  
    head = reverse(head); 
  
    System.out.println("Reversed Linked list"); 
    print(); 
}
}
  
// This code is contributed by Prakhar Agarwal


Python3




"""Python3 program to reverse linked list
using recursive method"""
  
# Linked List Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
  
# Create and Handle list operations
class LinkedList:
    def __init__(self):
        self.head = None # Head of list
  
    # Method to reverse the list
    def reverse(self, head):
  
        # If head is empty or has reached the list end
        if head is None or head.next is None:
            return head
  
        # Reverse the rest list
        rest = self.reverse(head.next)
  
        # Put first element at the end
        head.next.next = head
        head.next = None
  
        # Fix the header pointer
        return rest
  
    # Returns the linked list in display format
    def __str__(self):
        linkedListStr = ""
        temp = self.head
        while temp:
            linkedListStr = (linkedListStr + 
                            str(temp.data) + " ")
            temp = temp.next
        return linkedListStr
  
    # Pushes new data to the head of the list
    def push(self, data):
        temp = Node(data)
        temp.next = self.head
        self.head = temp
  
# Driver code
linkedList = LinkedList()
linkedList.push(20)
linkedList.push(4)
linkedList.push(15)
linkedList.push(85)
  
print("Given linked list")
print(linkedList)
  
linkedList.head = linkedList.reverse(linkedList.head)
  
print("Reversed linked list")
print(linkedList)
  
# This code is contributed by Debidutta Rath


C#




// Recursive C# program to 
// reverse a linked list
using System;
class recursion{ 
      
// Head of list 
static Node head; 
  
public class Node 
  public int data; 
  public Node next; 
  public Node(int d) 
  
    data = d; 
    next = null
  
  
static Node reverse(Node head) 
  if (head == null || 
      head.next == null
    return head; 
  
  // Reverse the rest list and put  
  // the first element at the end
  Node rest = reverse(head.next); 
  head.next.next = head; 
  
  // Tricky step -- 
  // see the diagram
  head.next = null
  
  // Fix the head pointer
  return rest; 
  
// Function to print 
// linked list 
static void print() 
  Node temp = head; 
  while (temp != null
  
    Console.Write(temp.data + " "); 
    temp = temp.next; 
  
  Console.WriteLine();
  
static void push(int data) 
  Node temp = new Node(data); 
  temp.next = head; 
  head = temp; 
  
// Driver code
public static void Main(String []args) 
  // Start with the 
  // empty list
  push(20); 
  push(4); 
  push(15); 
  push(85); 
  
  Console.WriteLine("Given linked list"); 
  print(); 
  head = reverse(head); 
  Console.WriteLine("Reversed Linked list"); 
  print(); 
}
}
  
// This code is contributed by gauravrajput1


Javascript




<script>
// Recursive javascript program to reverse
// a linked list
  
    var head; // head of list
     class Node {
        constructor(val) {
            this.data = val;
            this.next = null;
        }
    }
  
    function reverse(head) {
        if (head == null || head.next == null)
            return head;
  
        /*
         * reverse the rest list and put the first element at the end
         */
        var rest = reverse(head.next);
        head.next.next = head;
  
        /* tricky step -- see the diagram */
        head.next = null;
  
        /* fix the head pointer */
        return rest;
    }
  
    /* Function to print linked list */
    function print() {
    var temp = head;
        while (temp != null) {
            document.write(temp.data + " ");
            temp = temp.next;
        }
        document.write();
    }
  
    function push(data) {
    var temp = new Node(data);
        temp.next = head;
        head = temp;
    }
  
    /* Driver program to test above function */
      
        /* Start with the empty list */
  
        push(20);
        push(4);
        push(15);
        push(85);
  
        document.write("Given linked list<br/>");
        print();
  
        head = reverse(head);
  
        document.write("<br/>Reversed Linked list<br/>");
        print();
  
// This code is contributed by Rajput-Ji
</script>


Output: 

Given linked list
85 15 4 20 
Reversed Linked list
20 4 15 85

Time Complexity: O(n) 
Space Complexity: O(1)

A Simpler and Tail Recursive Method 

Below is the implementation of this method.  

C++




// A simple and tail recursive C++ program to reverse
// a linked list
#include <bits/stdc++.h>
using namespace std;
  
struct Node {
    int data;
    struct Node* next;
};
  
void reverseUtil(Node* curr, Node* prev, Node** head);
  
// This function mainly calls reverseUtil()
// with prev as NULL
void reverse(Node** head)
{
    if (!head)
        return;
    reverseUtil(*head, NULL, head);
}
  
// A simple and tail-recursive function to reverse
// a linked list.  prev is passed as NULL initially.
void reverseUtil(Node* curr, Node* prev, Node** head)
{
    /* If last node mark it head*/
    if (!curr->next) {
        *head = curr;
  
        /* Update next to prev node */
        curr->next = prev;
        return;
    }
  
    /* Save curr->next node for recursive call */
    Node* next = curr->next;
  
    /* and update next ..*/
    curr->next = prev;
  
    reverseUtil(next, curr, head);
}
  
// A utility function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->data = key;
    temp->next = NULL;
    return temp;
}
  
// A utility function to print a linked list
void printlist(Node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}
  
// Driver code
int main()
{
    Node* head1 = newNode(1);
    head1->next = newNode(2);
    head1->next->next = newNode(3);
    head1->next->next->next = newNode(4);
    head1->next->next->next->next = newNode(5);
    head1->next->next->next->next->next = newNode(6);
    head1->next->next->next->next->next->next = newNode(7);
    head1->next->next->next->next->next->next->next
        = newNode(8);
    cout << "Given linked list\n";
    printlist(head1);
    reverse(&head1);
    cout << "\nReversed linked list\n";
    printlist(head1);
    return 0;
}


Java




// Java program for reversing the Linked list
  
class LinkedList {
  
    static Node head;
  
    static class Node {
  
        int data;
        Node next;
  
        Node(int d)
        {
            data = d;
            next = null;
        }
    }
  
    // A simple and tail recursive function to reverse
    // a linked list.  prev is passed as NULL initially.
    Node reverseUtil(Node curr, Node prev)
    {
        /*If head is initially null OR list is empty*/
        if (head == null)
            return head;
        /* If last node mark it head*/
        if (curr.next == null) {
            head = curr;
  
            /* Update next to prev node */
            curr.next = prev;
  
            return head;
        }
  
        /* Save curr->next node for recursive call */
        Node next1 = curr.next;
  
        /* and update next ..*/
        curr.next = prev;
  
        reverseUtil(next1, curr);
        return head;
    }
  
    // prints content of double linked list
    void printList(Node node)
    {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);
        list.head.next.next.next = new Node(4);
        list.head.next.next.next.next = new Node(5);
        list.head.next.next.next.next.next = new Node(6);
        list.head.next.next.next.next.next.next
            = new Node(7);
        list.head.next.next.next.next.next.next.next
            = new Node(8);
  
        System.out.println("Original Linked list ");
        list.printList(head);
        Node res = list.reverseUtil(head, null);
        System.out.println("");
        System.out.println("");
        System.out.println("Reversed linked list ");
        list.printList(res);
    }
}
  
// This code has been contributed by Mayank Jaiswal


Python




# Simple and tail recursive Python program to
# reverse a linked list
  
# Node class
  
  
class Node:
  
    # Constructor to initialize the node object
    def __init__(self, data):
        self.data = data
        self.next = None
  
  
class LinkedList:
  
    # Function to initialize head
    def __init__(self):
        self.head = None
  
    def reverseUtil(self, curr, prev):
  
        # If last node mark it head
        if curr.next is None:
            self.head = curr
  
            # Update next to prev node
            curr.next = prev
            return
  
        # Save curr.next node for recursive call
        next = curr.next
  
        # And update next
        curr.next = prev
  
        self.reverseUtil(next, curr)
  
    # This function mainly calls reverseUtil()
    # with previous as None
  
    def reverse(self):
        if self.head is None:
            return
        self.reverseUtil(self.head, None)
  
    # Function to insert a new node at the beginning
  
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node
  
    # Utility function to print the linked LinkedList
    def printList(self):
        temp = self.head
        while(temp):
            print temp.data,
            temp = temp.next
  
  
# Driver code
llist = LinkedList()
llist.push(8)
llist.push(7)
llist.push(6)
llist.push(5)
llist.push(4)
llist.push(3)
llist.push(2)
llist.push(1)
  
print "Given linked list"
llist.printList()
  
llist.reverse()
  
print "\nReverse linked list"
llist.printList()
  
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)


C#




// C# program for reversing the Linked list
using System;
  
public class LinkedList {
    Node head;
    public class Node {
  
        public int data;
        public Node next;
  
        public Node(int d)
        {
            data = d;
            next = null;
        }
    }
  
    // A simple and tail-recursive function to reverse
    // a linked list. prev is passed as NULL initially.
    Node reverseUtil(Node curr, Node prev)
    {
  
        /* If last node mark it head*/
        if (curr.next == null) {
            head = curr;
  
            /* Update next to prev node */
            curr.next = prev;
  
            return head;
        }
  
        /* Save curr->next node for recursive call */
        Node next1 = curr.next;
  
        /* and update next ..*/
        curr.next = prev;
  
        reverseUtil(next1, curr);
        return head;
    }
  
    // prints content of double linked list
    void printList(Node node)
    {
        while (node != null) {
            Console.Write(node.data + " ");
            node = node.next;
        }
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);
        list.head.next.next.next = new Node(4);
        list.head.next.next.next.next = new Node(5);
        list.head.next.next.next.next.next = new Node(6);
        list.head.next.next.next.next.next.next
            = new Node(7);
        list.head.next.next.next.next.next.next.next
            = new Node(8);
  
        Console.WriteLine("Original Linked list ");
        list.printList(list.head);
        Node res = list.reverseUtil(list.head, null);
        Console.WriteLine("");
        Console.WriteLine("");
        Console.WriteLine("Reversed linked list ");
        list.printList(res);
    }
}
  
// This code contributed by Rajput-Ji


Output

Given linked list
1 2 3 4 5 6 7 8 

Reversed linked list
8 7 6 5 4 3 2 1

Using Stack:

  • Store the nodes(values and address) in the stack until all the values are entered.
  • Once all entries are done, Update the Head pointer to the last location(i.e the last value).
  • Start popping the nodes(value and address) and store them in the same order until the stack is empty.
  • Update the next pointer of last Node in the stack by NULL.

Below is the implementation of the above approach:

C++




// C++ program for above approach
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
  
// Create a class Node to enter 
// values and address in the list
class Node 
{
public:
    int data;
    Node* next;
};
  
// Function to reverse the 
// linked list
void reverseLL(Node** head)
{   
      
    // Create a stack "s" 
    // of Node type
    stack<Node*> s; 
    Node* temp = *head;
    while (temp->next != NULL) 
    {
          
        // Push all the nodes 
        // in to stack
        s.push(temp); 
        temp = temp->next;
    }
    *head = temp;
    
    while (!s.empty()) 
    {
          
        // Store the top value of
        // stack in list
        temp->next = s.top(); 
        
        // Pop the value from stack
        s.pop(); 
        
        // update the next pointer in the
        // in the list
        temp = temp->next; 
    }
    temp->next = NULL;
}
  
// Function to Display 
// the elements in List
void printlist(Node* temp) 
{
    while (temp != NULL) 
    {
        cout << temp->data << " ";
        temp = temp->next;
    }
}
  
// Program to insert back of the 
// linked list
void insert_back(Node** head, int value)
  
    // we have used insertion at back method
    // to enter values in the list.(eg:
    // head->1->2->3->4->Null)
    Node* temp = new Node();
    temp->data = value;
    temp->next = NULL;
      
    // If *head equals to NULL
    if (*head == NULL) 
    {
      *head = temp;
      return;
    }
    else 
    {
      Node* last_node = *head;
      while (last_node->next != NULL) 
      {
        last_node = last_node->next;
      }
      last_node->next = temp;
      return;
    }
}
  
// Driver Code
int main()
{
    Node* head = NULL;
  
    insert_back(&head, 1);
    insert_back(&head, 2);
    insert_back(&head, 3);
    insert_back(&head, 4);
    cout << "Given linked list\n";
    printlist(head);
    reverseLL(&head);
    cout << "\nReversed linked list\n";
    printlist(head);
    return 0;
}


Java




// Java program for above approach
import java.util.*;
  
class GFG{
  
// Create a class Node to enter 
// values and address in the list
static class Node 
{
  
    int data;
    Node next;
};
static Node head = null;
// Function to reverse the 
// linked list
static void reverseLL()
{   
      
    // Create a stack "s" 
    // of Node type
    Stack<Node> s = new Stack<>(); 
    Node temp = head;
    while (temp.next != null
    {
          
        // Push all the nodes 
        // in to stack
        s.add(temp); 
        temp = temp.next;
    }
    head = temp;
    
    while (!s.isEmpty()) 
    {
          
        // Store the top value of
        // stack in list
        temp.next = s.peek(); 
        
        // Pop the value from stack
        s.pop(); 
        
        // update the next pointer in the
        // in the list
        temp = temp.next; 
    }
    temp.next = null;
}
  
// Function to Display 
// the elements in List
static void printlist(Node temp) 
{
    while (temp != null
    {
        System.out.print(temp.data+ " ");
        temp = temp.next;
    }
}
  
// Program to insert back of the 
// linked list
static void insert_back( int value)
  
    // we have used insertion at back method
    // to enter values in the list.(eg:
    // head.1.2.3.4.Null)
    Node temp = new Node();
    temp.data = value;
    temp.next = null;
      
    // If *head equals to null
    if (head == null
    {
      head = temp;
      return;
    }
    else 
    {
      Node last_node = head;
      while (last_node.next != null
      {
        last_node = last_node.next;
      }
      last_node.next = temp;
      return;
    }
}
  
// Driver Code
public static void main(String[] args)
{
    insert_back( 1);
    insert_back( 2);
    insert_back(3);
    insert_back( 4);
    System.out.print("Given linked list\n");
    printlist(head);
    reverseLL();
    System.out.print("\nReversed linked list\n");
    printlist(head);
}
}
  
// This codeis contributed by gauravrajput1


C#




// C# program for above approach
using System;
using System.Collections.Generic;
  
class GFG{
  
// Create a class Node to enter 
// values and address in the list
public class Node 
{
    public int data;
    public Node next;
};
static Node head = null;
  
// Function to reverse the 
// linked list
static void reverseLL()
{
      
    // Create a stack "s" 
    // of Node type
    Stack<Node> s = new Stack<Node>(); 
    Node temp = head;
      
    while (temp.next != null
    {
          
        // Push all the nodes 
        // in to stack
        s.Push(temp); 
        temp = temp.next;
    }
    head = temp;
    
    while (s.Count != 0) 
    {
          
        // Store the top value of
        // stack in list
        temp.next = s.Peek(); 
        
        // Pop the value from stack
        s.Pop(); 
        
        // Update the next pointer in the
        // in the list
        temp = temp.next; 
    }
    temp.next = null;
}
  
// Function to Display 
// the elements in List
static void printlist(Node temp) 
{
    while (temp != null
    {
        Console.Write(temp.data + " ");
        temp = temp.next;
    }
}
  
// Function to insert back of the 
// linked list
static void insert_back( int value)
      
    // We have used insertion at back method
    // to enter values in the list.(eg:
    // head.1.2.3.4.Null)
    Node temp = new Node();
    temp.data = value;
    temp.next = null;
      
    // If *head equals to null
    if (head == null
    {
        head = temp;
        return;
    }
    else 
    {
        Node last_node = head;
          
        while (last_node.next != null
        {
            last_node = last_node.next;
        }
        last_node.next = temp;
        return;
    }
}
  
// Driver Code
public static void Main(String[] args)
{
    insert_back(1);
    insert_back(2);
    insert_back(3);
    insert_back(4);
    Console.Write("Given linked list\n");
      
    printlist(head);
    reverseLL();
      
    Console.Write("\nReversed linked list\n");
    printlist(head);
}
}
  
// This code is contributed by gauravrajput1


Python3




# Python code for the above approach
  
# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
  
  
class Solution:
    
    # Program to reverse the linked list
    # using stack
    def reverseLLUsingStack(self, head):
         
        # Initialise the variables
        stack, temp = [], head
          
        while temp:
            stack.append(temp)
            temp = temp.next
  
        head = temp = stack.pop()
          
        # Until stack is not 
        # empty
        while len(stack) > 0:
            elem = stack.pop()
            temp.next = elem
            temp = elem
  
        elem.next = None
        return head
  
# Driver Code
if __name__ == "__main__":
    head = ListNode(1, ListNode(2, ListNode(3
                        ListNode(4, ListNode(5)))))
    obj = Solution()
    head = obj.reverseLLUsingStack(head)
    while head:
        print(head.val, end=' ')
        head = head.next


Output

Given linked list
1 2 3 4 
Reversed linked list
4 3 2 1 

Thanks to Gaurav Ahirwar for suggesting this solution. 

Using array:

1. Create a linked list.

2. Then, make a count(head) function to count the number of nodes.

3. Initialize an array with the size of the count.

4. and start a while(p->next!=NULL) loop and store all the node’s data into the array.

5. and then print the array from the last index to the first.

C++




#include <iostream>
#include<cstdlib>
using namespace std;
  
typedef struct node
{
  int val;
  struct node* next;
}node;
  
node* head=NULL;
  
int count(node* head) // code to count the no. of nodes
{
  node* p=head;
  int k=1;
  while(p!=NULL)
  {
    p=p->next;
    k++;
  }
  return k;
}
  
node *ll_reverse(node* head)  // to reverse the linked list
{
  node* p=head;
  long int i=count(head),j=1;
  long int arr[i];
  while(i && p!=NULL)
  {
    arr[j++]=p->val;
    p=p->next;
    i--;
  }
  j--; 
  while(j) // loop will break as soon as j=0
  {
    cout<<arr[j--]<<" ";
  }
    
  return head;
}
  
node* insert_end(node* head,int data)  //code to insert at end of ll
{
  node* q=head,*p=(node*)malloc(sizeof(node));
  p->val=data;
  while(q->next!=NULL)
  {
    q=q->next;
  }
  q->next=p;
  p->next=NULL;
  return head;
}
  
node *create_ll(node* head,int data)  //create ll
{
  node* p=(node*)malloc(sizeof(node));
  p->val=data;
  if(head==NULL)
  {
    head=p;
    p->next=NULL;
    return head;
  }
  else
  {
    head=insert_end(head,data);
    return head;
  }
}
  
//Driver code
  
int main() 
{
  int i=5,j=1;  
  while(i--)
  {
    head=create_ll(head,j++);
  }
  head=ll_reverse(head);  
    return 0;
}


Java




// Java program of the above approach
class GFG {
  
    // Create a class Node to enter
    // values and address in the list
    static class node {
  
        int val;
        node next;
    };
  
    static node head = null;
  
    // code to count the no. of nodes
    static int count(node head)
    {
        node p = head;
        int k = 1;
        while (p != null) {
            p = p.next;
            k++;
        }
        return k;
    }
  
    // to reverse the linked list
    static node ll_reverse(node head)
    {
        node p = head;
        int i = count(head), j = 1;
        int[] arr = new int[i];
  
        while (i != 0 && p != null) {
            arr[j++] = p.val;
            p = p.next;
            i--;
        }
        j--;
        while (j != 0) // loop will break as soon as j=0
        {
            System.out.print(arr[j--] + " ");
        }
  
        return head;
    }
    // code to insert at end of ll
    static node insert_end(node head, int data)
    {
        node q = head;
        node p = new node();
        p.val = data;
        p.next = null;
        while (q.next != null) {
            q = q.next;
        }
        q.next = p;
        p.next = null;
        return head;
    }
  
    // create ll
    static node create_ll(node head, int data)
    {
        node p = new node();
        p.next = null;
        p.val = data;
        if (head == null) {
            head = p;
            p.next = null;
            return head;
        }
        else {
            head = insert_end(head, data);
            return head;
        }
    }
  
    public static void main(String[] args)
    {
        int i = 5, j = 1;
        while (i != 0) {
            head = create_ll(head, j++);
            i--;
        }
        head = ll_reverse(head);
    }
}
  
// This code is contributed by rajsanghavi9.


C#




// C# program of the above approach
using System;
  
public class GFG {
  
    // Create a class Node to enter
    // values and address in the list
    public
  
 class node {
  
        public
  
 int val;
        public
  
 node next;
    };
  
    static node head = null;
  
    // code to count the no. of nodes
    static int count(node head)
    {
        node p = head;
        int k = 1;
        while (p != null) {
            p = p.next;
            k++;
        }
        return k;
    }
  
    // to reverse the linked list
    static node ll_reverse(node head)
    {
        node p = head;
        int i = count(head), j = 1;
        int[] arr = new int[i];
  
        while (i != 0 && p != null) {
            arr[j++] = p.val;
            p = p.next;
            i--;
        }
        j--;
        while (j != 0) // loop will break as soon as j=0
        {
            Console.Write(arr[j--] + " ");
        }
  
        return head;
    }
    // code to insert at end of ll
    static node insert_end(node head, int data)
    {
        node q = head;
        node p = new node();
        p.val = data;
        p.next = null;
        while (q.next != null) {
            q = q.next;
        }
        q.next = p;
        p.next = null;
        return head;
    }
  
    // create ll
    static node create_ll(node head, int data)
    {
        node p = new node();
        p.next = null;
        p.val = data;
        if (head == null) {
            head = p;
            p.next = null;
            return head;
        }
        else {
            head = insert_end(head, data);
            return head;
        }
    }
  
    public static void Main(String[] args)
    {
        int i = 5, j = 1;
        while (i != 0) {
            head = create_ll(head, j++);
            i--;
        }
        head = ll_reverse(head);
    }
}
  
// This code is contributed by umadevi9616 


Input :  1->2->3->4->5
Output: 5->4->3->2->1
Time complexity: O(n)
Space complexity: O(n)

Recursively Reversing a linked list (A simple implementation) 
Iteratively Reverse a linked list using only 2 pointers (An Interesting Method)

References: 
http://cslibrary.stanford.edu/105/LinkedListProblems.pdf


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!