Related Articles

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

1->2->3->4->NULL
Output: Linked list should be changed to,
4->3->2->1->NULL

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 ``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 ``#include ` `/* 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

 ``

Output:

```Given linked list
85 15 4 20
20 4 15 85```

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

```   1) Divide the list in two parts - first node and
2) Call reverse for the rest of the linked list.

## C++

 `// Recursive C++ program to reverse``// a linked list``#include ``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`

Output:

```Given linked list
85 15 4 20
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 ``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

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 ``#include ``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 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 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 s = ``new` `Stack();``    ``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()``        ` `        ``# Untill 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
4 3 2 1 ```

Thanks to Gaurav Ahirwar for suggesting this solution.

Using array:

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 ``#include``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<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;``}`
```Input :  1->2->3->4->5
Output: 5->4->3->2->1```
```Time complexity: O(n)
Space complexity: O(n)```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up