 GFG App
Open App Browser
Continue

# Print reverse of a Linked List without actually reversing

Given a linked list, print reverse of it using a recursive function. For example, if the given linked list is 1->2->3->4, then output should be 4->3->2->1.
Note that the question is only about printing the reverse. To reverse the list itself see this
Difficulty Level: Rookie Algorithm

```printReverse(head)
1. call print reverse for head->next

Implementation:

## C++

 `// C++ program to print reverse of a linked list ` `#include ` `using` `namespace` `std;`   `/* Link list node */` `class` `Node ` `{ ` `    ``public``:` `    ``int` `data; ` `    ``Node* next; ` `}; `   `/* Function to reverse the linked list */` `void` `printReverse(Node* head) ` `{ ` `    ``// Base case ` `    ``if` `(head == NULL) ` `    ``return``; `   `    ``// print the list after head node ` `    ``printReverse(head->next); `   `    ``// After everything else is printed, print head ` `    ``cout << head->data << ``" "``; ` `} `   `/*UTILITY FUNCTIONS*/` `/* Push a node to linked list. Note that this function ` `changes the head */` `void` `push(Node** head_ref, ``char` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node* new_node = ``new` `Node();`   `    ``/* put in the data */` `    ``new_node->data = new_data; `   `    ``/* link the old list of the new node */` `    ``new_node->next = (*head_ref); `   `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} `   `/* Driver code*/` `int` `main() ` `{ ` `    ``// Let us create linked list 1->2->3->4 ` `    ``Node* head = NULL; ` `    ``push(&head, 4); ` `    ``push(&head, 3); ` `    ``push(&head, 2); ` `    ``push(&head, 1); ` `    `  `    ``printReverse(head); ` `    ``return` `0; ` `} `   `// This code is contributed by rathbhupendra`

## C

 `// C program to print reverse of a linked list` `#include` `#include` ` `  `/* Link list node */` `struct` `Node` `{` `    ``int` `data;` `    ``struct` `Node* next;` `};` ` `  `/* Function to reverse the linked list */` `void` `printReverse(``struct` `Node* head)` `{` `    ``// Base case  ` `    ``if` `(head == NULL)` `       ``return``;`   `    ``// print the list after head node` `    ``printReverse(head->next);`   `    ``// After everything else is printed, print head` `    ``printf``(``"%d  "``, head->data);` `}` ` `  `/*UTILITY FUNCTIONS*/` `/* Push a node to linked list. Note that this function` `  ``changes the head */` `void` `push(``struct` `Node** head_ref, ``char` `new_data)` `{` `    ``/* allocate node */` `    ``struct` `Node* new_node =` `            ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node));` ` `  `    ``/* put in the data  */` `    ``new_node->data  = new_data;` ` `  `    ``/* link the old list of the new node */` `    ``new_node->next = (*head_ref);   ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref)    = new_node;` `} ` ` `  `/* Driver program to test above function*/` `int` `main()` `{` `    ``// Let us create linked list 1->2->3->4` `    ``struct` `Node* head = NULL;    ` `    ``push(&head, 4);` `    ``push(&head, 3);` `    ``push(&head, 2);` `    ``push(&head, 1);` `  `  `    ``printReverse(head);` `    ``return` `0;` `}`

## Java

 `// Java program to print reverse of a linked list` `class` `LinkedList` `{` `    ``Node head;  ``// head of list`   `    ``/* Linked list Node*/` `    ``class` `Node` `    ``{` `        ``int` `data;` `        ``Node next;` `        ``Node(``int` `d) {data = d; next = ``null``; }` `    ``}`   `    ``/* Function to print reverse of linked list */` `    ``void` `printReverse(Node head)` `    ``{` `        ``if` `(head == ``null``) ``return``;`   `        ``// print list of head node` `        ``printReverse(head.next);`   `        ``// After everything else is printed` `        ``System.out.print(head.data+``" "``);` `    ``}`   `    ``/* Utility Functions */`   `    ``/* Inserts a new Node at front of the list. */` `    ``public` `void` `push(``int` `new_data)` `    ``{` `        ``/* 1 & 2: Allocate the Node &` `                  ``Put in the data*/` `        ``Node new_node = ``new` `Node(new_data);`   `        ``/* 3. Make next of new Node as head */` `        ``new_node.next = head;`   `        ``/* 4. Move the head to point to new Node */` `        ``head = new_node;` `    ``}`   `    ``/*Driver function to test the above methods*/` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``// Let us create linked list 1->2->3->4` `        ``LinkedList llist = ``new` `LinkedList();` `        ``llist.push(``4``);` `        ``llist.push(``3``);` `        ``llist.push(``2``);` `        ``llist.push(``1``);`   `        ``llist.printReverse(llist.head);` `    ``}` `}` `/* This code is contributed by Rajat Mishra */`

## Python3

 `# Python3 program to print reverse` `# of 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` `    `  `    ``# Recursive function to print ` `    ``# linked list in reverse order` `    ``def` `printrev(``self``, temp):` `        `  `        ``if` `temp:` `            ``self``.printrev(temp.``next``)` `            ``print``(temp.data, end ``=` `' '``)` `        ``else``:` `            ``return` `        `  `    ``# 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 `   `# Driver code` `llist ``=` `LinkedList() `   `llist.push(``4``) ` `llist.push(``3``) ` `llist.push(``2``) ` `llist.push(``1``) `   `llist.printrev(llist.head)` `    `  `# This code is contributed by Vinay Kumar(vinaykumar71)`

## C#

 `// C# program to print reverse of a linked list` `using` `System;`   `public` `class` `LinkedList` `{` `    ``Node head; ``// head of list`   `    ``/* Linked list Node*/` `    ``class` `Node` `    ``{` `        ``public` `int` `data;` `        ``public` `Node next;` `        ``public` `Node(``int` `d) ` `        ``{` `            ``data = d; next = ``null``;` `        ``}` `    ``}`   `    ``/* Function to print reverse of linked list */` `    ``void` `printReverse(Node head)` `    ``{` `        ``if` `(head == ``null``) ``return``;`   `        ``// print list of head node` `        ``printReverse(head.next);`   `        ``// After everything else is printed` `        ``Console.Write(head.data + ``" "``);` `    ``}`   `    ``/* Utility Functions */`   `    ``/* Inserts a new Node at front of the list. */` `    ``public` `void` `push(``int` `new_data)` `    ``{` `        ``/* 1 & 2: Allocate the Node &` `                ``Put in the data*/` `        ``Node new_node = ``new` `Node(new_data);`   `        ``/* 3. Make next of new Node as head */` `        ``new_node.next = head;`   `        ``/* 4. Move the head to point to new Node */` `        ``head = new_node;` `    ``}`   `    ``/*Driver function to test the above methods*/` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``// Let us create linked list 1->2->3->4` `        ``LinkedList llist = ``new` `LinkedList();` `        ``llist.push(4);` `        ``llist.push(3);` `        ``llist.push(2);` `        ``llist.push(1);`   `        ``llist.printReverse(llist.head);` `    ``}` `}`   `// This code has been contributed by Rajput-Ji `

## Javascript

 ``

Output

`4 3 2 1 `

Time Complexity: O(n)

Auxiliary Space: O(n) for stack space since using recursion

Another approach:

We can also perform the same action using a stack using iterative method.

Algorithm:

```Store the values of the linked list in a stack.
Keep removing the elements from the stack and print them.```

Implementation:

## C++

 `// C++ program to print reverse of a linked list using iterative method` `#include ` `using` `namespace` `std;`   `/* Link list node */` `class` `Node ` `{ ` `    ``public``:` `    ``int` `data; ` `    ``Node* next; ` `}; `   `/* Function to print the reverse of the linked list using iterative method */` `void` `printReverse(Node* head) ` `{ ` `    ``stack<``int``> st;` `    ``Node *curr = head;` `    ``while``(curr!=NULL)` `    ``{` `      ``st.push(curr->data);` `      ``curr = curr->next;` `    ``}` `      ``while``(st.empty()==``false``)` `    ``{` `      ``cout << st.top()<<``" -> "``;` `      ``st.pop();` `    ``}` `} `   `/*UTILITY FUNCTIONS*/` `/* function to print the elements of the linked list*/` `void` `printList(Node *head)` `{` `  ``Node *curr = head;` `  ``while``(curr!=NULL)` `  ``{` `    ``cout << curr->data << ``" -> "``;` `    ``curr = curr->next;` `  ``}` `  ``cout<<``"\n"``;` `}` `/* Push a node to linked list. Note that this function ` `changes the head */` `void` `push(Node** head_ref, ``char` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node* new_node = ``new` `Node();`   `    ``/* put in the data */` `    ``new_node->data = new_data; `   `    ``/* link the old list of the new node */` `    ``new_node->next = (*head_ref); `   `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} `   `/* Driver code*/` `int` `main() ` `{ ` `    ``// Let us create linked list 1->2->3->4 ` `    ``Node* head = NULL; ` `    ``push(&head, 4); ` `    ``push(&head, 3); ` `    ``push(&head, 2); ` `    ``push(&head, 1); ` `    ``printList(head);` `    ``printReverse(head); ` `    ``return` `0; ` `} `   `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

## Java

 `// Java program to print reverse of a linked list using iterative method` `import` `java.util.*;` `class` `LinkedList` `{` `    ``Node head;  ``// head of list`   `    ``/* Linked list Node*/` `    ``class` `Node` `    ``{` `        ``int` `data;` `        ``Node next;` `        ``Node(``int` `d) {data = d; next = ``null``; }` `    ``}`   `    ``/* Function to print reverse of linked list */` `    ``void` `printReverse(Node head)` `    ``{` `        ``Stack st = ``new` `Stack();` `        ``Node curr = head;` `        ``while``(curr!=``null``)` `        ``{` `          ``st.push(curr.data);` `          ``curr = curr.next;` `        ``}` `          ``while``(st.isEmpty()==``false``)` `        ``{` `          ``System.out.print(st.peek() + ``" -> "``);` `          ``st.pop();` `        ``}` `    ``}`   `    ``/* Utility Functions */` `    ``/* function to print the elements of the linked list*/` `    ``void` `printList(Node head)` `    ``{` `          ``Node curr = head;` `          ``while``(curr!=``null``)` `          ``{` `            ``System.out.print(curr.data + ``" -> "``);` `            ``curr = curr.next;` `          ``}` `         ``System.out.println();` `    ``}` `    ``/* Inserts a new Node at front of the list. */` `    ``public` `void` `push(``int` `new_data)` `    ``{` `        ``/* 1 & 2: Allocate the Node &` `                  ``Put in the data*/` `        ``Node new_node = ``new` `Node(new_data);`   `        ``/* 3. Make next of new Node as head */` `        ``new_node.next = head;`   `        ``/* 4. Move the head to point to new Node */` `        ``head = new_node;` `    ``}`   `    ``/*Driver function to test the above methods*/` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``// Let us create linked list 1->2->3->4` `        ``LinkedList llist = ``new` `LinkedList();` `        ``llist.push(``4``);` `        ``llist.push(``3``);` `        ``llist.push(``2``);` `        ``llist.push(``1``);` `        ``llist.printList(llist.head);` `        ``llist.printReverse(llist.head);` `    ``}` `}` `/* This code is contributed by Abhijeet Kumar(abhijeet19403) */`

## Python3

 `# Python3 program to print reverse` `# of a linked list using iterative method`   `# 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` `    `  `    ``# Recursive function to print ` `    ``# linked list in reverse order using iterative method` `    ``def` `printrev(``self``, curr):` `        ``stack ``=` `[]` `        ``while` `curr:` `            ``stack.append(curr)` `            ``curr ``=` `curr.``next` `            `  `        ``while` `len``(stack):` `            ``print``(stack.pop().data,``"->"` `, end ``=` `' '``)` `        ``print``()    ` `        `  `    ``#Function to print the linked list` `    ``def` `printlist(``self``,curr):` `        ``while` `curr:` `            ``print``(curr.data,``"->"` `, end ``=` `' '``)` `            ``curr ``=` `curr.``next` `        ``print``()` `        `  `    ``# 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 `   `# Driver code` `llist ``=` `LinkedList() `   `llist.push(``4``) ` `llist.push(``3``) ` `llist.push(``2``) ` `llist.push(``1``) `   `llist.printlist(llist.head)` `llist.printrev(llist.head)` `    `  `# This code is contributed by Abhijeet Kumar(abhijeet19403)`

## C#

 `// C# program to print reverse of a linked list` `using` `System;` `using` `System.Collections;` `public` `class` `LinkedList {` `    ``Node head; ``// head of list`   `    ``/* Linked list Node*/` `    ``class` `Node {` `        ``public` `int` `data;` `        ``public` `Node next;` `        ``public` `Node(``int` `d)` `        ``{` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}`   `    ``/* Function to print reverse of linked list */` `    ``void` `printReverse(Node head)` `    ``{` `        ``Stack st = ``new` `Stack();` `        ``Node curr = head;` `        ``while` `(curr != ``null``) {` `            ``st.Push(curr.data);` `            ``curr = curr.next;` `        ``}` `        ``while` `(st.Count != 0) {` `            ``Console.Write(st.Peek() + ``" -> "``);` `            ``st.Pop();` `        ``}` `        ``Console.Write(``"\n"``);` `    ``}`   `    ``/* Utility Functions */` `    ``/* A function to print the elements of the list*/` `    ``void` `printList(Node head)` `    ``{` `        ``Node curr = head;` `        ``while` `(curr != ``null``) {` `            ``Console.Write(curr.data + ``" -> "``);` `            ``curr = curr.next;` `        ``}` `        ``Console.Write(``"\n"``);` `    ``}` `    ``/* Inserts a new Node at front of the list. */` `    ``public` `void` `push(``int` `new_data)` `    ``{` `        ``/* 1 & 2: Allocate the Node &` `                ``Put in the data*/` `        ``Node new_node = ``new` `Node(new_data);`   `        ``/* 3. Make next of new Node as head */` `        ``new_node.next = head;`   `        ``/* 4. Move the head to point to new Node */` `        ``head = new_node;` `    ``}`   `    ``/*Driver function to test the above methods*/` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``// Let us create linked list 1->2->3->4` `        ``LinkedList llist = ``new` `LinkedList();` `        ``llist.push(4);` `        ``llist.push(3);` `        ``llist.push(2);` `        ``llist.push(1);` `        ``llist.printList(llist.head);` `        ``llist.printReverse(llist.head);` `    ``}` `}`   `// This code has been contributed by Abhijeet Kumar(abhijeet19403)`

## Javascript

 ``

Output

```1 -> 2 -> 3 -> 4 ->
4 -> 3 -> 2 -> 1 -> ```

Time Complexity: O(N)

As we are traversing the linked list only once.

Auxiliary Space: O(N)

The extra space is used in storing the elements in the stack.