 Open in App
Not now

# An interesting method to print reverse of a linked list

• Difficulty Level : Easy
• Last Updated : 10 Mar, 2023

We are given a linked list, we need to print the linked list in reverse order.
Examples:

```Input : list : 5-> 15-> 20-> 25
Output : Reversed Linked list : 25-> 20-> 15-> 5

Input : list : 85-> 15-> 4-> 20
Output : Reversed Linked list : 20-> 4-> 15-> 85

Input : list : 85
Output : Reversed Linked list : 85```

For printing a list in reverse order, we have already discussed Iterative and Recursive Methods to Reverse.
In this post, an interesting method is discussed, that doesn’t require recursion and does no modifications to list. The function also visits every node of linked list only once.

Trick : Idea behind printing a list in reverse order without any recursive function or loop is to use Carriage return (“r”). For this, we should have knowledge of length of list. Now, we should print n-1 blank space and then print 1st element then “r”, further again n-2 blank space and 2nd node then “r” and so on..
Carriage return (“r”) : It commands a printer (cursor or the display of a system console), to move the position of the cursor to the first position on the same line.

C/C++

` `

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `// Represents node of a linkedlist` `class` `Node {` `  ``public``:` `      ``int` `data;` `      ``Node *next;` `      ``Node(``int` `val)` `      ``{` `          ``data = val;` `          ``next = nullptr;` `      ``}` `};` `  `  `void` `printReverse(Node *head, ``int` `n)` `{` `        ``int` `j = 0;` `        ``Node *current = head;` `        ``while` `(current != nullptr) {` `           `  `           ``// For each node, print proper number ` `           ``// of spaces before printing it ` `           ``for` `(``int` `i = 0; i < 2 * (n - j); i++)` `                ``cout << ``" "``;`   `           ``// use of carriage return to move back ` `           ``// and print.` `           ``cout << ``"\r"` `<< current->data;`   `           ``current = current->next;` `           ``j++; ` `        ``}` `}`   `Node *push(Node *head, ``int` `data) ` `{` `        ``Node *new_node = ``new` `Node(data);` `        ``new_node->next = head;` `        ``head = new_node;`   `        ``return` `head;` `}`   `int` `printList(Node *head)` `{` `        ``// i for finding length of list ` `        ``int` `i = 0;` `        ``Node *temp = head;` `        ``while` `(temp != nullptr)` `        ``{` `               ``cout << temp->data << ``" "``;` `               ``temp = temp->next;` `               ``i++;` `        ``}`   `        ``return` `i;` `}` `  `  `// Driver code` `int` `main()` `{` `      ``/* Start with the empty list */` `      ``Node *head = nullptr;`   `      ``// list nodes are as 6 5 4 3 2 1` `      ``head = push(head, 1);` `      ``head = push(head, 2);` `      ``head = push(head, 3);` `      ``head = push(head, 4);` `      ``head = push(head, 5);` `      ``head = push(head, 6);`   `      ``cout << ``"Given linked list: "` `<< endl;` `      ``// printlist print the list and ` `      ``// return the size of list ` `      ``int` `n = printList(head); `   `      ``// print reverse list with help ` `      ``// of carriage return function` `      ``cout << ``"Reversed Linked list: "` `<< endl;` `      ``printReverse(head, n); ` `      ``cout << endl;`   `      ``return` `0;` `}` `//this code is contributed by snehalsalokhe`

## Java

 `// Java program to print reverse of list` `import` `java.io.*;` `import` `java.util.*;`   `// Represents node of a linkedlist` `class` `Node {` `    ``int` `data;` `    ``Node next;` `    ``Node(``int` `val)` `    ``{` `        ``data = val;` `        ``next = ``null``;` `    ``}` `}`   `public` `class` `GFG {`   `    ``/* Function to reverse the linked list */` `    ``static` `void` `printReverse(Node head, ``int` `n)` `    ``{` `        ``int` `j = ``0``;` `        ``Node current = head;` `        ``while` `(current != ``null``) {`   `            ``// For each node, print proper number` `            ``// of spaces before printing it` `            ``for` `(``int` `i = ``0``; i < ``2` `* (n - j); i++)` `                ``System.out.print(``" "``);`   `            ``// use of carriage return to move back` `            ``// and print.` `            ``System.out.print(``" "` `+ current.data);`   `            ``current = current.next;` `            ``j++;` `        ``}` `    ``}`   `    ``/* Function to push a node */` `    ``static` `Node push(Node head, ``int` `data)` `    ``{` `        ``Node new_node = ``new` `Node(data);` `        ``new_node.next = head;` `        ``head = new_node;`   `        ``return` `head;` `    ``}`   `    ``/* Function to print linked list and find its` `    ``length */` `    ``static` `int` `printList(Node head)` `    ``{` `        ``// i for finding length of list` `        ``int` `i = ``0``;` `        ``Node temp = head;` `        ``while` `(temp != ``null``) {` `            ``System.out.print(temp.data + ``" "``);` `            ``temp = temp.next;` `            ``i++;` `        ``}`   `        ``return` `i;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``/* Start with the empty list */` `        ``Node head = ``null``;`   `        ``// list nodes are as 6 5 4 3 2 1` `        ``head = push(head, ``1``);` `        ``head = push(head, ``2``);` `        ``head = push(head, ``3``);` `        ``head = push(head, ``4``);` `        ``head = push(head, ``5``);` `        ``head = push(head, ``6``);`   `        ``System.out.println(``"Given linked list: "``);`   `        ``// printlist print the list and` `        ``// return the size of list` `        ``int` `n = printList(head);`   `        ``// print reverse list with help` `        ``// of carriage return function` `        ``System.out.println(``"\nReversed Linked list: "``);` `        ``printReverse(head, n);` `        ``System.out.println();` `    ``}` `}`   `// This code is contributed by rachana soma`

## C#

 `// C# program to print reverse of list` `using` `System;` `  `  `// Represents node of a linkedlist` `public` `class` `Node {` `      ``public` `int` `data;` `      ``public` `Node next;` `      ``public` `Node(``int` `val)` `      ``{` `          ``data = val;` `          ``next = ``null``;` `      ``}` `}` `  `  `public` `class` `GFG` `{` `  `  `   ``/* Function to reverse the linked list */` `   ``static` `void` `printReverse(Node head, ``int` `n)` `   ``{` `          ``int` `j = 0;` `          ``Node current = head;` `          ``while` `(current != ``null``) {` `             `  `             ``// For each node, print proper number ` `             ``// of spaces before printing it ` `             ``for` `(``int` `i = 0; i < 2 * (n - j); i++)` `                  ``Console.Write(``" "``);`   `             ``// use of carriage return to move back ` `             ``// and print.` `             ``Console.Write(``"\r"` `+ current.data);`   `             ``current = current.next;` `             ``j++; ` `          ``}` `   ``}`   `   ``/* Function to push a node */` `   ``static` `Node push(Node head, ``int` `data) ` `   ``{` `          ``Node new_node = ``new` `Node(data);` `          ``new_node.next = head;` `          ``head = new_node;`   `          ``return` `head;` `   ``}`   `   ``/* Function to print linked list and find its ` `   ``length */` `   ``static` `int` `printList(Node head)` `   ``{` `          ``// i for finding length of list ` `          ``int` `i = 0;` `          ``Node temp = head;` `          ``while` `(temp != ``null``)` `          ``{` `                 ``Console.Write(temp.data + ``" "``);` `                 ``temp = temp.next;` `                 ``i++;` `          ``}`   `          ``return` `i;` `   ``}` `  `  `   ``// Driver code` `   ``public` `static` `void` `Main(String []args)` `   ``{` `      ``/* Start with the empty list */` `      ``Node head = ``null``;`   `      ``// list nodes are as 6 5 4 3 2 1` `      ``head = push(head, 1);` `      ``head = push(head, 2);` `      ``head = push(head, 3);` `      ``head = push(head, 4);` `      ``head = push(head, 5);` `      ``head = push(head, 6);`   `      ``Console.WriteLine(``"Given linked list: "``);` `      ``// printlist print the list and ` `      ``// return the size of list ` `      ``int` `n = printList(head); `   `      ``// print reverse list with help ` `      ``// of carriage return function` `      ``Console.WriteLine(``"Reversed Linked list: "``);` `      ``printReverse(head, n); ` `      ``Console.WriteLine();` `   ``}` `}` `  `  `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to print reverse of list` ` `  `# Link list node ` `class` `Node:` `    ``def` `__init__(``self``):` `        ``self``.data``=`  `0` `        ``self``.``next``=``None` ` `  `# Function to reverse the linked list ` `def` `printReverse( head_ref, n):` ` `  `    ``j ``=` `0` `    ``current ``=` `head_ref` `    ``while` `(current !``=` `None``): ` `        ``i ``=` `0` `        `  `        ``# For each node, print proper number` `        ``# of spaces before printing it` `        ``while` `( i < ``2` `*` `(n ``-` `j) ):` `            ``print``(end``=``" "``)` `            ``i ``=` `i ``+` `1` `  `  `        ``# use of carriage return to move back` `        ``# and print.` `        ``print``( current.data, end ``=` `"\r"``)` `  `  `        ``current ``=` `current.``next` `        ``j ``=` `j ``+` `1` `     `  ` ``# Function to push a node ` `def` `push( head_ref, new_data):` ` `  `    ``new_node ``=` `Node() ` `  `  `    ``new_node.data ``=` `new_data` `    ``new_node.``next` `=` `(head_ref)` `    ``(head_ref) ``=` `new_node` `    ``return` `head_ref;` `  `  `# Function to print linked list and find its` `#  length ` `def` `printList( head):` ` `  `    ``# i for finding length of list` `    ``i ``=` `0` `    ``temp ``=` `head` `    ``while` `(temp !``=` `None``): ` `        ``print``( temp.data,end ``=` `" "``)` `        ``temp ``=` `temp.``next` `        ``i ``=` `i ``+` `1` `     `  `    ``return` `i` ` `  `# Driver program to test above function` ` `  `# Start with the empty list ` `head ``=` `None`   `# list nodes are as 6 5 4 3 2 1` `head ``=` `push(head, ``1``)` `head ``=` `push(head, ``2``)` `head ``=` `push(head, ``3``)` `head ``=` `push(head, ``4``)` `head ``=` `push(head, ``5``)` `head ``=` `push(head, ``6``)` `  `  `print``(``"Given linked list:"``)`   `# printlist print the list and` `# return the size of list` `n ``=` `printList(head)` `  `  `# print reverse list with help` `# of carriage return function` `print``(``"\nReversed Linked list:"``)` `printReverse(head, n)` `print``()` ` `  `# This code is contributed by Arnab Kundu`

## Javascript

 ``

Output:

```Given linked list:
6 5 4 3 2 1
1 2 3 4 5 6```

Time Complexity: O(N).
Auxiliary Space: O(1),

Input and Output Illustration :
Input: 6 5 4 3 2 1
1st Iteration _ _ _ _ _ 6
2nd Iteration _ _ _ _ 5 6
3rd Iteration _ _ _ 4 5 6
4th Iteration _ _ 3 4 5 6
5th Iteration _ 2 3 4 5 6
Final Output 1 2 3 4 5 6
NOTE: Above program may not work on online compilers because they do not support anything like carriage return on their console.
Reference :
StackOverflow/Carriage return