  Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email  Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# Find modular node in a linked list

Last Updated on November 29, 2022 by Prepbytes This blog will discuss the best way to solve the famous question “modular node in linked list”. Finding a modular node in linked list will make your linked list topic strong. Having knowledge about data structures like linked list will definitely help in cracking the technical interview of tech giants like Samsung, Amazon, TCS, Wipro, Capgemini, Accenture and Cognizant. Let’s move to our topic to find a modular node in linked list.

## How To Find Modular Node In Linked List

In this problem, we have been given a linked list and a positive integer k. Our task is to find the last node whose n%k==0, where n denotes the position of this last node in the linked list.

Let’s try to understand the problem with the help of examples by referring to online programming courses.

Suppose we are given a linked list A → B → C → D → E → F and k = 3.

• According to the problem statement, we have to find the last node of the linked list whose n%k==0, where this n denotes the node’s position in the linked list.
• For the above given linked list, we can see that only for n=3 and n=6 our n%k==0. But as 6>3:

• So we will have to return the 6th node of the linked list as our output, as it is the last node of the linked list for which n%k==0.

Output: F

If the linked list is A → B → C → D → E → F → G → H → I and k = 4.

• For the above given linked list, we can see that only for n=4 and n=8 our n%k==0. But as 8>4:

• So we will have to return the 8th node of the linked list as our output, as it is the last node of the linked list for which n%k==0.

Output: H

Note: Here in this problem, we are considering 1 based indexing.

Some more examples
Input : Output : 6

Input : Output : 9

Now I think from the above examples the problem is clear, and now we have to think about how we can approach it.

## Approach To Find Modular Node In Linked List

Our approach will be simple:

• We will traverse the linked list and whenever for any node i%k==0 (i denotes the position of the current node in the linked list) we will update our modular node to be equal to the current node.
• Finally, we will have our modular node at the end of the loop, and now we can return it.

The algorithm for the approach is explained below.

## Algorithm To Find Modular Node In Linked List

• We will take a pointer modNode and initialize it with NULL. This pointer will keep track of the last node whose i%k==0.
• Now we will traverse the list and for every i%k==0, we will update our modNode to be equal to the current node.
• Finally, at the end when our list traversal is over, we will return modNode as our output.

### Dry Run To Find Modular Node In Linked List  ## Code Implementation To Find Modular Node In Linked List

```#include<stdio.h>
#include<stdlib.h>

struct Node {
int data;
struct Node* next;
};

/* Function to create a new node with given data */
struct Node* newNode(int data)
{
struct Node* new_node = malloc(sizeof(struct Node*));
new_node->data = data;
new_node->next = NULL;
return new_node;
}

/* Function to find modular node in the linked list */
struct Node* modularNode(struct Node* head, int k)
{
// Corner cases
if (k <= 0 || head == NULL)
return NULL;

// Traverse the given list
int i = 1;
struct Node* modularNode = NULL;
for (struct 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)
{
int k = 2;
printf("\nModular node is ");
else
printf("null\n");
return 0;
}
```
```#include <bits stdc++.h="">

struct Node {
int data;
Node* next;
};

Node* newNode(int data)
{
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
return new_node;
}

{
if (k <= 0 || head == NULL)
return NULL;

int i = 1;
Node* modNode = NULL;
for (Node* temp = head; temp != NULL; temp = temp->next) {
if (i % k == 0)
modNode = temp;

i++;
}
return modNode;
}

int main()
{
int k = 2;
printf("\nModular node is ");
else
printf("null\n");
return 0;
}
```
```class Modular
{
static class Node
{
int data;
Node next;
Node(int data){
this.data = data;
}
}
static Node modularNode(Node head, int k)
{
if (k <= 0 || head == null)
return null;

int i = 1;
Node modularNode = null;
for (Node temp = head; temp != null; temp = temp.next) {
if (i % k == 0)
modularNode = temp;

i++;
}
return modularNode;
}
public static void main(String[] args)
{
int k = 2;
System.out.print("Modular node is ");
else
System.out.println("null");
}
}
```
```class Node:
def __init__(self, data):
self.data = data
self.next = None

def newNode(data):
new_node = Node(data)
new_node.data = data
new_node.next = None
return new_node

if (k <= 0 or head == None):
return None

i = 1
modularNode = None
while (temp != None):
if (i % k == 0):
modularNode = temp

i = i + 1
temp = temp.next
return modularNode

if __name__ == '__main__':
k = 2
print("Modular node is", end = ' ')
else:
print("None")
```
``````Output
Modular node is 7``````

Time Complexity To Find Modular Node In Linked List: O(n), as we are traversing the complete length of the list

This blog discusses the best way to find modular node in linked List. Linked list is a must practice topic to prepare for the data structures. Our experts have made the most asked questions for the interview’s questions for linked list, you can follow this link Linked List for practicing more questions of linked list.

## FAQ

1. What is a modular node in the linked list?
A modular node is the last node of the linked list whose Index is divisible by the number k, i.e. i%k==0.

2. How do you find the last node in a linked list?
The last node of a linked list has the reference pointer as NULL. i.e. node=>next = NULL. To find the last node, we have to iterate the linked till the node=>next != NULL.

3. What is the last node called?
The first node is called the head; it points to the first node of the list and helps us access every other element in the list. The last node, also sometimes called the tail, points to NULL which helps us in determining when the list ends.