Related Articles
Find the fractional (or n/k – th) node in linked list
• Difficulty Level : Easy
• Last Updated : 28 Nov, 2019

Given a singly linked list and a number k, write a function to find the (n/k)-th element, where n is the number of elements in the list. We need to consider ceil value in case of decimals.

Examples:

```Input : list = 1->2->3->4->5->6
k = 2
Output : 3
Since n = 6 and k = 2, we print (6/2)-th node
which is 3.

Input : list = 2->7->9->3->5
k = 3
Output : 7
Since n is 5 and k is 3, we print ceil(5/3)-th
node which is 2nd node, i.e., 7.
```

## Recommended: Please solve it on PRACTICE first, before moving on to the solution.

1. Take two pointers temp and fractionalNode and initialize them with null and head respectively.
2. For every k jumps of the temp pointer, make one jump of the fractionalNode pointer.

## C++

 `// C++ program to find fractional 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 fractional node in the linked list */``Node* fractionalNodes(Node* head, ``int` `k)``{``    ``// Corner cases``    ``if` `(k <= 0 || head == NULL)``        ``return` `NULL;`` ` `    ``Node* fractionalNode = NULL;``     ` `    ``// Traverse the given list ``    ``int` `i = 0;``    ``for` `(Node* temp = head; temp != NULL; temp = temp->next) {`` ` `        ``// For every k nodes, we move fractionalNode one``        ``// step ahead. ``        ``if` `(i % k == 0) {`` ` `            ``// First time we see a multiple of k``            ``if` `(fractionalNode == NULL)``                ``fractionalNode = head;`` ` `            ``else``                ``fractionalNode = fractionalNode->next;``        ``}``        ``i++;``    ``}``    ``return` `fractionalNode;``}`` ` `// A utility function to print a linked list``void` `printList(Node* node)``{``    ``while` `(node != NULL) {``        ``printf``(``"%d "``, node->data);``        ``node = node->next;``    ``}``    ``printf``(``"\n"``);``}`` ` `/* 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;`` ` `    ``printf``(``"List is "``);``    ``printList(head);`` ` `    ``Node* answer = fractionalNodes(head, k);``    ``printf``(``"\nFractional node is "``);``    ``printf``(``"%d\n"``, answer->data);`` ` `    ``return` `0;``}`

## Java

 `// Java program to find fractional node in``// a linked list``public` `class` `FractionalNodell``{``    ``/* Linked list node */``    ``static` `class` `Node{``        ``int` `data;``        ``Node next;`` ` `        ``//Constructor``        ``Node (``int` `data){``            ``this``.data = data;``        ``}``    ``}`` ` `    ``/* Function to find fractional node in the``       ``linked list */``    ``static` `Node fractionalNodes(Node head, ``int` `k)``    ``{``        ``// Corner cases``        ``if` `(k <= ``0` `|| head == ``null``)``            ``return` `null``;`` ` `        ``Node fractionalNode = ``null``;`` ` `        ``// Traverse the given list``        ``int` `i = ``0``;``        ``for` `(Node temp = head; temp != ``null``;``                          ``temp = temp.next){`` ` `            ``// For every k nodes, we move``            ``// fractionalNode one step ahead.``            ``if` `(i % k == ``0``){`` ` `                ``// First time we see a multiple of k``                ``if` `(fractionalNode == ``null``)``                    ``fractionalNode = head;``                ``else``                    ``fractionalNode = fractionalNode.next;``            ``}``            ``i++;``        ``}``        ``return` `fractionalNode;``    ``}`` ` `    ``// A utility function to print a linked list``    ``static` `void` `printList(Node node)``    ``{``        ``while` `(node != ``null``)``        ``{``            ``System.out.print(node.data+``" "``);``            ``node = node.next;``        ``}``        ``System.out.println();``    ``}`` ` `    ``/* Driver program 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``;`` ` `        ``System.out.print(``"List is "``);``        ``printList(head);`` ` `        ``Node answer = fractionalNodes(head, k);``        ``System.out.println(``"Fractional node is "``+``                                      ``answer.data);``    ``}``}``// This code is contributed by Sumit Ghosh`

## Python3

 `# Python3 program to find fractional 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 fractional node ``# in the linked list``def` `fractionalNodes(head, k):``     ` `    ``# Corner cases``    ``if` `(k <``=` `0` `or` `head ``=``=` `None``):``        ``return` `None`` ` `    ``fractionalNode ``=` `None`` ` `    ``# Traverse the given list``    ``i ``=` `0``    ``temp ``=` `head``    ``while` `(temp !``=` `None``):``         ` `        ``# For every k nodes, we move ``        ``# fractionalNode one step ahead. ``        ``if` `(i ``%` `k ``=``=` `0``):`` ` `            ``# First time we see a multiple of k``            ``if` `(fractionalNode ``=``=` `None``):``                ``fractionalNode ``=` `head`` ` `            ``else``:``                ``fractionalNode ``=` `fractionalNode.``next`` ` `        ``i ``=` `i ``+` `1``        ``temp ``=` `temp.``next`` ` `    ``return` `fractionalNode`` ` `# A utility function to print a linked list``def` `prList(node):``    ``while` `(node !``=` `None``):``        ``print``(node.data, end ``=` `' '``)``        ``node ``=` `node.``next`` ` `# 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`` ` `    ``print``(``"List is"``, end ``=` `' '``)``    ``prList(head)`` ` `    ``answer ``=` `fractionalNodes(head, k)``    ``print``(``"\nFractional node is"``, end ``=` `' '``)``    ``print``(answer.data)`` ` `# This code is contributed by Srathore`

## C#

 `// C# program to find fractional node in``// a linked list``using` `System;`` ` `public` `class` `FractionalNodell``{``    ``/* Linked list node */``    ``public` `class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node next;`` ` `        ``//Constructor``        ``public` `Node (``int` `data)``        ``{``            ``this``.data = data;``        ``}``    ``}`` ` `    ``/* Function to find fractional node in the``    ``linked list */``    ``static` `Node fractionalNodes(Node head, ``int` `k)``    ``{``        ``// Corner cases``        ``if` `(k <= 0 || head == ``null``)``            ``return` `null``;`` ` `        ``Node fractionalNode = ``null``;`` ` `        ``// Traverse the given list``        ``int` `i = 0;``        ``for` `(Node temp = head; temp != ``null``;``                        ``temp = temp.next)``        ``{`` ` `            ``// For every k nodes, we move``            ``// fractionalNode one step ahead.``            ``if` `(i % k == 0)``            ``{`` ` `                ``// First time we see a multiple of k``                ``if` `(fractionalNode == ``null``)``                    ``fractionalNode = head;``                ``else``                    ``fractionalNode = fractionalNode.next;``            ``}``            ``i++;``        ``}``        ``return` `fractionalNode;``    ``}`` ` `    ``// A utility function to print a linked list``    ``static` `void` `printList(Node node)``    ``{``        ``while` `(node != ``null``)``        ``{``            ``Console.Write(node.data+``" "``);``            ``node = node.next;``        ``}``        ``Console.WriteLine();``    ``}`` ` `    ``/* 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;`` ` `        ``Console.Write(``"List is "``);``        ``printList(head);`` ` `        ``Node answer = fractionalNodes(head, k);``        ``Console.WriteLine(``"Fractional node is "``+``                                    ``answer.data);``    ``}``}`` ` `// This code is contributed by Rajput-Ji`

Output:
```
List is 1 2 3 4 5
Fractional node is 3
```

This article is contributed by Prakriti Gupta. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up