# Print the last k nodes of the linked list in reverse order | Recursive approach

Given a linked list containing N nodes and a positive integer k should be less than or equal to N. The task is to print the last k nodes of the list in reverse order.

Examples:

```Input: list: 1->2->3->4->5, k = 2
Output: 5 4

Input: list: 3->10->6->9->12->2->8, k = 4
Output: 8 2 12 9
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Recursive Approach: Recursively traverse the linked list. When returning from each recursive call keep track of the node number, considering the last node as number 1, second last as number 2 and so on. This counting could be tracked with the help of a global or pointer variable. With the help of this count variable, print the nodes having a node number less than or equal to k.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to print the last k nodes ` `// of linked list in reverse order ` `#include ` `using` `namespace` `std; ` ` `  `// Structure of a node ` `struct` `Node { ` `    ``int` `data; ` `    ``Node* next; ` `}; ` ` `  `// Function to get a new node ` `Node* getNode(``int` `data) ` `{ ` `    ``// allocate space ` `    ``Node* newNode = ``new` `Node; ` ` `  `    ``// put in data ` `    ``newNode->data = data; ` `    ``newNode->next = NULL; ` `    ``return` `newNode; ` `} ` ` `  `// Function to print the last k nodes ` `// of linked list in reverse order ` `void` `printLastKRev(Node* head, ` `                     ``int``& count, ``int` `k) ` `{ ` `    ``// if list is empty ` `    ``if` `(!head) ` `        ``return``; ` ` `  `    ``// Recursive call with the next node ` `    ``// of the list ` `    ``printLastKRev(head->next, count, k); ` ` `  `    ``// Count variable to keep track of ` `    ``// the last k nodes ` `    ``count++; ` ` `  `    ``// Print data ` `    ``if` `(count <= k) ` `        ``cout << head->data << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Create list: 1->2->3->4->5 ` `    ``Node* head = getNode(1); ` `    ``head->next = getNode(2); ` `    ``head->next->next = getNode(3); ` `    ``head->next->next->next = getNode(4); ` `    ``head->next->next->next->next = getNode(5); ` ` `  `    ``int` `k = 4, count = 0; ` ` `  `    ``// print the last k nodes ` `    ``printLastKRev(head, count, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to print the last k nodes  ` `// of linked list in reverse order  ` `class` `GfG  ` `{ ` ` `  `// Structure of a node  ` `static` `class` `Node  ` `{  ` `    ``int` `data;  ` `    ``Node next;  ` `} ` ` `  `// Function to get a new node  ` `static` `Node getNode(``int` `data)  ` `{  ` `    ``// allocate space  ` `    ``Node newNode = ``new` `Node();  ` ` `  `    ``// put in data  ` `    ``newNode.data = data;  ` `    ``newNode.next = ``null``;  ` `    ``return` `newNode;  ` `}  ` ` `  `static` `class` `C ` `{ ` `    ``int` `count = ``0``; ` `} ` ` `  `// Function to print the last k nodes  ` `// of linked list in reverse order  ` `static` `void` `printLastKRev(Node head, C c, ``int` `k)  ` `{  ` `    ``// if list is empty  ` `    ``if` `(head == ``null``)  ` `        ``return``;  ` ` `  `    ``// Recursive call with the next node  ` `    ``// of the list  ` `    ``printLastKRev(head.next, c, k);  ` ` `  `    ``// Count variable to keep track of  ` `    ``// the last k nodes  ` `    ``c.count++;  ` ` `  `    ``// Print data  ` `    ``if` `(c.count <= k)  ` `        ``System.out.print(head.data + ``" "``);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``// Create list: 1->2->3->4->5  ` `    ``Node head = getNode(``1``);  ` `    ``head.next = getNode(``2``);  ` `    ``head.next.next = getNode(``3``);  ` `    ``head.next.next.next = getNode(``4``);  ` `    ``head.next.next.next.next = getNode(``5``);  ` ` `  `    ``int` `k = ``4``; ` `    ``C c = ``new` `C(); ` ` `  `    ``// print the last k nodes  ` `    ``printLastKRev(head, c, k);  ` `} ` `}  ` `  `  `// This code is contributed by prerna saini `

## C#

 `// C# implementation to print the last k   ` `// nodes of linked list in reverse order ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `// Structure of a node  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node next;  ` `} ` ` `  `// Function to get a new node  ` `static` `Node getNode(``int` `data)  ` `{  ` `    ``// allocate space  ` `    ``Node newNode = ``new` `Node();  ` ` `  `    ``// put in data  ` `    ``newNode.data = data;  ` `    ``newNode.next = ``null``;  ` `    ``return` `newNode;  ` `}  ` ` `  `public` `class` `C ` `{ ` `    ``public` `int` `count = 0; ` `} ` ` `  `// Function to print the last k nodes  ` `// of linked list in reverse order  ` `static` `void` `printLastKRev(Node head, C c, ``int` `k)  ` `{  ` `    ``// if list is empty  ` `    ``if` `(head == ``null``)  ` `        ``return``;  ` ` `  `    ``// Recursive call with the next  ` `    ``// node of the list  ` `    ``printLastKRev(head.next, c, k);  ` ` `  `    ``// Count variable to keep track   ` `    ``// of the last k nodes  ` `    ``c.count++;  ` ` `  `    ``// Print data  ` `    ``if` `(c.count <= k)  ` `        ``Console.Write(head.data + ``" "``);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String []args)  ` `{  ` `     `  `    ``// Create list: 1->2->3->4->5  ` `    ``Node head = getNode(1);  ` `    ``head.next = getNode(2);  ` `    ``head.next.next = getNode(3);  ` `    ``head.next.next.next = getNode(4);  ` `    ``head.next.next.next.next = getNode(5);  ` ` `  `    ``int` `k = 4; ` `    ``C c = ``new` `C(); ` ` `  `    ``// print the last k nodes  ` `    ``printLastKRev(head, c, k);  ` `} ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

Output:

```5 4 3 2
```

Time Complexity: O(n).

Iterative Approach: The idea is to use Stack Data Structure.

1. Push all linked list nodes to a stack.
2. Pop k nodes from stack and print them.

Time Complexity: O(n).

Two Pointer Approach The idea is similar to find k-th node from end of linked list.

1. Move first pointer k nodes ahead.
2. Now start another pointer, second from head.
3. When first pointer reaches end, second pointer points to k-th node.
4. Finally using the second pointer, print last k nodes.

Time Complexity: O(n).

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.