Reverse a linked list

Difficulty Level :
Medium
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
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Input: 1->NULL Output: 1->NULL  
Iterative Method 
Initialize three pointers prev as NULL, curr as head and next as NULL.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
Initialize three pointers prev as NULL, curr as head and next as NULL.
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++
C
Java
Python
C#
Javascript
// 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;}
// 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 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 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 codellist = 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# program for reversing the linked listusing 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
<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) Auxiliary Space: 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
C++
Java
Python3
C#
Javascript
// 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;}
// Recursive Java program to reverse// a linked listclass 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 program to reverse linked listusing recursive method""" # Linked List Nodeclass Node:    def __init__(self, data):        self.data = data        self.next = None # Create and Handle list operationsclass 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 codelinkedList = 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
// Recursive C# program to// reverse a linked listusing System;class recursion{     // Head of liststatic 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 liststatic 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 codepublic 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
<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) Auxiliary Space: O(n)
A Simpler and Tail Recursive Method 
Below is the implementation of this method.  
C++
C
Java
Python
C#
Javascript
// 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 NULLvoid 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 nodeNode* newNode(int key){    Node* temp = new Node;    temp->data = key;    temp->next = NULL;    return temp;} // A utility function to print a linked listvoid printlist(Node* head){    while (head != NULL) {        cout << head->data << " ";        head = head->next;    }    cout << endl;} // Driver codeint 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;} // This code is contributed by Aditya Kumar (adityakumar129)
// A simple and tail recursive C program to reverse a linked list#include <stdio.h>#include <stdlib.h> typedef struct Node {    int data;    struct Node* next;}Node; void reverseUtil(Node* curr, Node* prev, Node** head); // This function mainly calls reverseUtil()// with prev as NULLvoid 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 nodeNode* newNode(int key){    Node* temp = (Node *)malloc(sizeof(Node));    temp->data = key;    temp->next = NULL;    return temp;} // A utility function to print a linked listvoid printlist(Node* head){    while (head != NULL) {        printf("%d ",head->data);        head = head->next;    }    printf("\n");} // Driver codeint 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);    printf("Given linked list\n");    printlist(head1);    reverse(&head1);    printf("\nReversed linked list\n");    printlist(head1);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// 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 is contributed by Aditya Kumar (adityakumar129)
# 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 codellist = 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# program for reversing the Linked listusing 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
<script>// javascript program for reversing the Linked list     var head; class Node {        constructor(d) {            this.data = d;            this.next = null;        }    }     // A simple and tail recursive function to reverse    // a linked list. prev is passed as NULL initially.    function reverseUtil(curr,  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 */        var next1 = curr.next;         /* and update next .. */        curr.next = prev;         reverseUtil(next1, curr);        return head;    }     // prints content of var linked list    function printList(node) {        while (node != null) {            document.write(node.data + " ");            node = node.next;        }    }     // Driver Code        var 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);        head.next.next.next.next.next = new Node(6);        head.next.next.next.next.next.next = new Node(7);        head.next.next.next.next.next.next.next = new Node(8);         document.write("Original Linked list<br/> ");        printList(head);        var res = reverseUtil(head, null);        document.write("<br/>");        document.write("<br/>");        document.write("Reversed linked list <br/>");        printList(res); // This code is contributed by Rajput-Ji</script>
  
Given linked list
1 2 3 4 5 6 7 8 

Reversed linked list
8 7 6 5 4 3 2 1
Time Complexity: O(N)
As we do certain operation for every node of the linked list.
Auxiliary Space: O(1)
As constant extra space is used.
Head Recursive Method:
C++
// Head recursive C++ program to reverse a linked list#include <iostream>using namespace std; // Linked list nodeclass Node {public:    int data;    Node* next;     // constructor: automatically assigns the value to the    // data and next pointer to NULL    Node(){};    Node(int val)        : data(val)        , next(NULL){};}; void reverseUtil(Node* curr, Node* prev, Node** headref){    // Base Case - If curr is last node    if (curr->next == NULL) {        // Update head of the linked list        *headref = curr;        // Update next to prev node        curr->next = prev;        return;    }    // Recursive Call for next node    reverseUtil(curr->next, curr, headref);    // Update next to prev node    curr->next = prev;} void reverse(Node** headref){    // If linked list is empty or contains single node    if (*headref == NULL || (*headref)->next == NULL)        return;    // Call reverseUtil() with prev as NULL    reverseUtil(*headref, NULL, headref);} // Function to insert a node at the end of linked listvoid push(Node** headref, int x){    Node* newptr = new Node(x);    if (*headref == NULL) {        *headref = newptr;    }    else {        Node* temp = *headref;        while (temp->next != NULL) {            temp = temp->next;        }        temp->next = newptr;    }} // Functio to print the linked listvoid print(Node* headref){    while (headref != NULL) {        cout << headref->data << " ";        headref = headref->next;    }    cout << "\n";} int main(){    Node* head = NULL;     // head->1->2->3->4->5->6->NULL    push(&head, 1);    push(&head, 2);    push(&head, 3);    push(&head, 4);    push(&head, 5);    push(&head, 6);     cout << "Given Linked List\n";    print(head);     reverse(&head);    cout << "Reversed Linked List\n";    print(head);    return 0;} //This code is contributed by Anisha Wagh
Output:
Given Linked List
1 2 3 4 5 6

Reversed Linked List
6 5 4 3 2 1
Time Complexity : O(N)
Using Stack:
Algorithm – 
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++
Java
C#
Python3
Javascript
// 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 listclass Node {public:    int data;    Node* next;}; // Function to reverse the linked listvoid 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 list        temp = temp->next;    }    temp->next = NULL;} // Function to Display the elements in Listvoid printlist(Node* temp){    while (temp != NULL) {        cout << temp->data << " ";        temp = temp->next;    }} // Program to insert back of the linked listvoid 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 Codeint 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;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java program for above approachimport 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 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 code is contributed by Aditya Kumar (adityakumar129)
// C# program for above approachusing System;using System.Collections.Generic; class GFG{ // Create a class Node to enter// values and address in the listpublic class Node{    public int data;    public Node next;};static Node head = null; // Function to reverse the// linked liststatic 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 Liststatic void printlist(Node temp){    while (temp != null)    {        Console.Write(temp.data + " ");        temp = temp.next;    }} // Function to insert back of the// linked liststatic 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 Codepublic 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
# 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:            temp.next = stack.pop()            temp = temp.next         temp.next = None        return head # Driver Codeif __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
<script>// javascript program for above approach // Create a class Node to enter// values and address in the list class Node{     constructor(){    this.data = 0;    this.next = null;}}var head = null;// Function to reverse the// linked listfunction reverseLL(){           // Create a stack "s"    // of Node type    var s = [];    var temp = head;    while (temp.next != null)    {                 // Push all the nodes        // in to stack        s.push(temp);        temp = temp.next;    }    head = temp;       while (s.length!=0)    {                 // Store the top value of        // stack in list        temp.next = s.pop();                             // update the next pointer in the        // in the list        temp = temp.next;    }    temp.next = null;} // Function to Display// the elements in Listfunction printlist(temp){    while (temp != null)    {        document.write(temp.data+ " ");        temp = temp.next;    }} // Program to insert back of the// linked listfunction insert_back(  value){     // we have used insertion at back method    // to enter values in the list.(eg:    // head.1.2.3.4.Null)    var temp = new Node();    temp.data = value;    temp.next = null;         // If *head equals to null    if (head == null)    {      head = temp;      return;    }    else    {      var last_node = head;      while (last_node.next != null)      {        last_node = last_node.next;      }      last_node.next = temp;      return;    }} // Driver Code         insert_back(1);        insert_back(2);        insert_back(3);        insert_back(4);        document.write("Given linked list\n");        printlist(head);        reverseLL();        document.write("<br/>Reversed linked list\n");        printlist(head);  // This code is contributed by umadevi9616</script>
Given linked list
1 2 3 4 
Reversed linked list
4 3 2 1 
Thanks to Gaurav Ahirwar for suggesting this solution. 
Time Complexity: O(N)
As we do certain operation for every node of the linked list.
Auxiliary Space: O(N)
Space is used to store the nodes in the stack.
Using array:
Algorithm :- 
1. Create a linked list.
2. Count the number of nodes present in the Linked List
3. Initialize an array with the size of the count.
4. Store the elements of the Linked list in array 
5. Print the array from the last index to the first.
C++
C
Java
C#
Javascript
#include <bits/stdc++.h>using namespace std; typedef struct node {    int val;    struct node* next;} node; node* head = NULL; // Function to return the No of nodes present in the linked listint count(node* head){    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;} // Function to insert node at the end of linked listnode* insert_end(node* head, int data){    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;} // This code is contributed by Aditya Kumar (adityakumar129)
#include<stdio.h>#include<stdlib.h> typedef struct node {    int val;    struct node* next;} node; node* head = NULL; // Function to return the No of nodes present in the linked listint count(node* head){    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;    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        printf("%d ",arr[j--]);    return head;} // Function to insert node at the end of linked listnode* insert_end(node* head, int data){    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;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java program of the above approachclass 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 Aditya Kumar (adityakumar129)
// C# program of the above approachusing 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
<script>// Javascript program of the above approach // Create a class Node to enter values and address in the listclass node {  constructor() {    this.val = null;    this.next = null;  }}; let head = null;// code to count the no. of nodesfunction count(head) {  let p = head;  let k = 1;  while (p != null) {    p = p.next;    k++;  }  return k;} // to reverse the linked listfunction ll_reverse(head) {  let p = head;  let i = count(head), j = 1;  let arr = new Array(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    document.write(arr[j--] + " ");  return head;}// code to insert at end of llfunction insert_end(head, data) {  let q = head;  let 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 llfunction create_ll(head, data) {  let 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;  }} let i = 5, j = 1;while (i != 0) {  head = create_ll(head, j++);  i--;}head = ll_reverse(head); // This code is contributed by gfgking</script>
Input :  1->2->3->4->5
Output: 5->4->3->2->1
Time complexity: O(N) as we visit every node once.
Auxiliary Space: O(N) as extra space is used to store all the nodes in the array.
Recursively Reversing a linked list (A simple implementation) Iteratively Reverse a linked list using only 2 pointers (An Interesting Method)
Reversing a linked list | GeeksforGeeks - YouTubeGeeksforGeeks530K subscribersReversing a linked list | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 1:45•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=D7y_hoT_YZI" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
References: http://cslibrary.stanford.edu/105/LinkedListProblems.pdf
AshishKumar22
andrew1234
Mayank Sharma 25
Rajput-Ji
prakhar7
AmiyaRanjanRout
manavgoswami001
GauravRajput1
SumitSingh41
avishekarora
madhav_mohan
mdusmanansari
todaysgaurav
rajsanghavi9
umadevi9616
arorakashish0911
nnr223442
lokeshmajeti
nishantchandhok
adityakumar129
gfgking
abhijeet19403
anishawagh2
mitalibhola94
Accolite
Adobe
Amazon
MakeMyTrip
Microsoft
Qualcomm
Reverse
Samsung
SAP Labs
Snapdeal
Zoho
Linked List
Zoho
Accolite
Amazon
Microsoft
Samsung
Snapdeal
MakeMyTrip
Adobe
SAP Labs
Qualcomm
Linked List
Reverse
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stack Data Structure (Introduction and Program)
LinkedList in Java
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Implementing a Linked List in Java using Class
Add two numbers represented by linked lists | Set 1
Detect and Remove Loop in a Linked List
Function to check if a singly linked list is palindrome
Queue - Linked List Implementation
Implement a stack using singly linked list