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)
Auxiliary Space: 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`

## Javascript

 ``

Output:

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

 `// 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;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// A simple and tail recursive C program to reverse a linked list` `#include ` `#include `   `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 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 = (Node *)``malloc``(``sizeof``(Node));` `    ``temp->data = key;` `    ``temp->next = NULL;` `    ``return` `temp;` `}`   `// A utility function to print a linked list` `void` `printlist(Node* head)` `{` `    ``while` `(head != NULL) {` `        ``printf``(``"%d "``,head->data);` `        ``head = head->next;` `    ``}` `    ``printf``(``"\n"``);` `}`   `// 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);` `    ``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

 `// 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)`

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

## Javascript

 ``

Output

```Given linked list
1 2 3 4 5 6 7 8

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.

## C++

 `// Head recursive C++ program to reverse a linked list` `#include ` `using` `namespace` `std;`   `// Linked list node` `class` `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 list` `void` `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 list` `void` `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

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

 `// 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;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## 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 code is contributed by Aditya Kumar (adityakumar129)`

## 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()` `        `  `        ``# Until stack is not ` `        ``# empty` `        ``while` `len``(stack) > ``0``:` `            ``temp.``next` `=` `stack.pop()` `            ``temp ``=` `temp.``next`   `        ``temp.``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`

## Javascript

 ``

Output

```Given linked list
1 2 3 4
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 :-

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

 `#include ` `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 list` `int` `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 list` `node* 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)`

## C

 `#include` `#include`   `typedef` `struct` `node {` `    ``int` `val;` `    ``struct` `node* next;` `} node;`   `node* head = NULL;`   `// Function to return the No of nodes present in the linked list` `int` `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 list` `node* 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

 `// 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 Aditya Kumar (adityakumar129)`

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

## Javascript

 ``

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :