Given a linked list of n nodes which is first sorted, then rotated by k elements. Find the value of k.

The idea is to traverse singly linked list to check condition whether current node value is greater than value of next node. If the given condition is true, then break the loop. Otherwise increase the counter variable and increase the node by node->next. Below is the implementation of this approach.

`// Program for count number of rotations in ` `// sorted linked list. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `/* Linked list node */` `struct` `Node { ` ` ` `int` `data; ` ` ` `struct` `Node* next; ` `}; ` ` ` `// Function that count number of ` `// rotation in singly linked list. ` `int` `countRotation(` `struct` `Node* head) ` `{ ` ` ` `// declare count variable and assign it 1. ` ` ` `int` `count = 0; ` ` ` ` ` `// declare a min variable and assign to ` ` ` `// data of head node. ` ` ` `int` `min = head->data; ` ` ` ` ` `// check that while head not equal to NULL. ` ` ` `while` `(head != NULL) { ` ` ` ` ` `// if min value is greater then head->data ` ` ` `// then it breaks the while loop and ` ` ` `// return the value of count. ` ` ` `if` `(min > head->data) ` ` ` `break` `; ` ` ` ` ` `count++; ` ` ` ` ` `// head assign the next value of head. ` ` ` `head = head->next; ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Function to push element in linked list. ` `void` `push(` `struct` `Node** head, ` `int` `data) ` `{ ` ` ` `// Allocate dynamic memory for newNode. ` ` ` `struct` `Node* newNode = ` `new` `Node; ` ` ` ` ` `// Assign the data into newNode. ` ` ` `newNode->data = data; ` ` ` ` ` `// newNode->next assign the address of ` ` ` `// head node. ` ` ` `newNode->next = (*head); ` ` ` ` ` `// newNode become the headNode. ` ` ` `(*head) = newNode; ` `} ` ` ` `// Display linked list. ` `void` `printList(` `struct` `Node* node) ` `{ ` ` ` `while` `(node != NULL) { ` ` ` `printf` `(` `"%d "` `, node->data); ` ` ` `node = node->next; ` ` ` `} ` `} ` ` ` `// Driver functions ` `int` `main() ` `{ ` ` ` `// Create a node and initialize with NULL ` ` ` `struct` `Node* head = NULL; ` ` ` ` ` `// push() insert node in linked list. ` ` ` `// 15 -> 18 -> 5 -> 8 -> 11 -> 12 ` ` ` `push(&head, 12); ` ` ` `push(&head, 11); ` ` ` `push(&head, 8); ` ` ` `push(&head, 5); ` ` ` `push(&head, 18); ` ` ` `push(&head, 15); ` ` ` ` ` `printList(head); ` ` ` `cout << endl; ` ` ` `cout << ` `"Linked list rotated elements: "` `; ` ` ` ` ` `// Function call countRotation() ` ` ` `cout << countRotation(head) << endl; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

Linked List: 15 18 5 8 11 12 Linked list rotated elements: 2

This article is contributed by **Dharmendra Kumar**. 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.

## Recommended Posts:

- Find the Rotation Count in Rotated Sorted array
- Search an element in a sorted and rotated array
- Given a sorted and rotated array, find if there is a pair with a given sum
- Check if an array is sorted and rotated
- Count of rotations required to generate a sorted array
- Sort a Rotated Sorted Array
- Given a linked list which is sorted, how will you insert in sorted way
- Insert value in sorted way in a sorted doubly linked list
- Merge K sorted Doubly Linked List in Sorted Order
- Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some Common nodes
- Count number of rotated strings which have more number of vowels in the first half than second half
- Count rotations of N which are Odd and Even
- Sorted merge of two sorted doubly circular linked lists
- Count rotations divisible by 4
- Count rotations divisible by 8
- Count rotations which are divisible by 10
- Maximize count of corresponding same elements in given permutations using cyclic rotations
- Count triplets in a sorted doubly linked list whose sum is equal to a given value x
- Count triplets in a sorted doubly linked list whose product is equal to a given value x
- Difference between Singly linked list and Doubly linked list