# Find modular node in a linked list

• Difficulty Level : Easy
• Last Updated : 22 Jun, 2022

Given a singly linked list and a number k, find the last node whose n%k == 0, where n is the number of nodes in the list.
Examples:

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

Input : list = 3->7->1->9->8
k = 2
Output : 9```

1. Take a pointer modularNode and initialize it with NULL. Traverse the linked list.
2. For every i%k=0, update modularNode.

## C++

 `// C++ program to find modular node in a linked list ` `#include ` ` `  `/* Linked list node */` `struct` `Node { ` `    ``int` `data; ` `    ``Node* next; ` `}; ` ` `  `/* Function to create a new node with given data */` `Node* newNode(``int` `data) ` `{ ` `    ``Node* new_node = ``new` `Node; ` `    ``new_node->data = data; ` `    ``new_node->next = NULL; ` `    ``return` `new_node; ` `} ` ` `  `/* Function to find modular node in the linked list */` `Node* modularNode(Node* head, ``int` `k) ` `{ ` `    ``// Corner cases ` `    ``if` `(k <= 0 || head == NULL) ` `        ``return` `NULL;    ` ` `  `    ``// Traverse the given list ` `    ``int` `i = 1; ` `    ``Node* modularNode = NULL; ` `    ``for` `(Node* temp = head; temp != NULL; temp = temp->next) { ` `        ``if` `(i % k == 0)  ` `            ``modularNode = temp; ` `         `  `        ``i++; ` `    ``} ` `    ``return` `modularNode; ` `} ` ` `  `/* Driver program to test above function */` `int` `main(``void``) ` `{ ` `    ``Node* head = newNode(1); ` `    ``head->next = newNode(2); ` `    ``head->next->next = newNode(3); ` `    ``head->next->next->next = newNode(4); ` `    ``head->next->next->next->next = newNode(5); ` `    ``int` `k = 2; ` `    ``Node* answer = modularNode(head, k); ` `    ``printf``(``"\nModular node is "``); ` `    ``if` `(answer != NULL)  ` `        ``printf``(``"%d\n"``, answer->data); ` `    ``else` `        ``printf``(``"null\n"``); ` `    ``return` `0; ` `} `

## Java

 `// A Java program to find modular node in a linked list ` `public` `class` `GFG ` `{ ` `    ``// A Linkedlist node ` `    ``static` `class` `Node{ ` `        ``int` `data; ` `        ``Node next; ` `        ``Node(``int` `data){ ` `            ``this``.data = data; ` `        ``} ` `    ``} ` `     `  `    ``// Function to find modular node in the linked list ` `    ``static` `Node modularNode(Node head, ``int` `k) ` `    ``{ ` `        ``// Corner cases ` `        ``if` `(k <= ``0` `|| head == ``null``) ` `            ``return` `null``;    ` `      `  `        ``// Traverse the given list ` `        ``int` `i = ``1``; ` `        ``Node modularNode = ``null``; ` `        ``for` `(Node temp = head; temp != ``null``; temp = temp.next) { ` `            ``if` `(i % k == ``0``)  ` `                ``modularNode = temp; ` `              `  `            ``i++; ` `        ``} ` `        ``return` `modularNode; ` `    ``} ` `     `  `    ``// Driver code to test above function ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``Node head = ``new` `Node(``1``); ` `        ``head.next = ``new` `Node(``2``); ` `        ``head.next.next = ``new` `Node(``3``); ` `        ``head.next.next.next = ``new` `Node(``4``); ` `        ``head.next.next.next.next = ``new` `Node(``5``); ` `        ``int` `k = ``2``; ` `        ``Node answer = modularNode(head, k); ` `        ``System.out.print(``"Modular node is "``); ` `        ``if` `(answer != ``null``)  ` `            ``System.out.println(answer.data); ` `        ``else` `            ``System.out.println(``"null"``); ` `    ``} ` `} ` `// This code is contributed by Sumit Ghosh `

## Python3

 `# Python3 program to find modular node  ` `# in a linked list ` `import` `math ` ` `  `# Linked list node ` `class` `Node: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` ` `  `# Function to create a new node  ` `# with given data ` `def` `newNode(data): ` `    ``new_node ``=` `Node(data) ` `    ``new_node.data ``=` `data ` `    ``new_node.``next` `=` `None` `    ``return` `new_node ` ` `  `# Function to find modular node  ` `# in the linked list ` `def` `modularNode(head, k): ` `     `  `    ``# Corner cases ` `    ``if` `(k <``=` `0` `or` `head ``=``=` `None``): ` `        ``return` `None` ` `  `    ``# Traverse the given list ` `    ``i ``=` `1` `    ``modularNode ``=` `None` `    ``temp ``=` `head ` `    ``while` `(temp !``=` `None``): ` `        ``if` `(i ``%` `k ``=``=` `0``): ` `            ``modularNode ``=` `temp ` ` `  `        ``i ``=` `i ``+` `1` `        ``temp ``=` `temp.``next` `    ``return` `modularNode ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``head ``=` `newNode(``1``) ` `    ``head.``next` `=` `newNode(``2``) ` `    ``head.``next``.``next` `=` `newNode(``3``) ` `    ``head.``next``.``next``.``next` `=` `newNode(``4``) ` `    ``head.``next``.``next``.``next``.``next` `=` `newNode(``5``) ` `    ``k ``=` `2` `    ``answer ``=` `modularNode(head, k) ` `    ``print``(``"Modular node is"``, end ``=` `' '``) ` `    ``if` `(answer !``=` `None``): ` `        ``print``(answer.data, end ``=` `' '``) ` `    ``else``: ` `        ``print``(``"None"``) ` ` `  `# This code is contributed by Srathore `

## C#

 `// C# program to find modular node in a linked list ` `using` `System; ` ` `  `class` `GFG  ` `{  ` `    ``// A Linkedlist node  ` `    ``public` `class` `Node ` `    ``{  ` `        ``public` `int` `data;  ` `        ``public` `Node next;  ` `        ``public` `Node(``int` `data) ` `        ``{  ` `            ``this``.data = data;  ` `        ``}  ` `    ``}  ` `     `  `    ``// Function to find modular node in the linked list  ` `    ``static` `Node modularNode(Node head, ``int` `k)  ` `    ``{  ` `        ``// Corner cases  ` `        ``if` `(k <= 0 || head == ``null``)  ` `            ``return` `null``;  ` `     `  `        ``// Traverse the given list  ` `        ``int` `i = 1;  ` `        ``Node modularNode = ``null``;  ` `        ``for` `(Node temp = head; temp != ``null``; temp = temp.next) ` `        ``{  ` `            ``if` `(i % k == 0)  ` `                ``modularNode = temp;  ` `             `  `            ``i++;  ` `        ``}  ` `        ``return` `modularNode;  ` `    ``}  ` `     `  `    ``// Driver code   ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{  ` `        ``Node head = ``new` `Node(1);  ` `        ``head.next = ``new` `Node(2);  ` `        ``head.next.next = ``new` `Node(3);  ` `        ``head.next.next.next = ``new` `Node(4);  ` `        ``head.next.next.next.next = ``new` `Node(5);  ` `        ``int` `k = 2;  ` ` `  `        ``Node answer = modularNode(head, k);  ` `        ``Console.Write(``"Modular node is "``);  ` ` `  `        ``if` `(answer != ``null``)  ` `            ``Console.WriteLine(answer.data);  ` `        ``else` `            ``Console.WriteLine(``"null"``);  ` `    ``}  ` `}  ` ` `  `// This code is contributed by Rajput-JI `

## Javascript

 ` `

Output:

`Modular node is 4`

Complexity Analysis:

Time Complexity: O(n).

Space complexity: O(1).

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