Given a linked list consisting of **N** nodes and an integer **K**, the task is to split the given Linked List into **K **continuous groups such that the difference between the size of the adjacent groups after splitting is **at most 1** and the groups are sorted in descending order of their lengths.**Note**: A group with 0 elements can also be formed.

**Examples:**

Input:1 → 2 → 3 → 4, K = 5Output:{{1}, {2}, {3}, {4}, {}}Explanation:Required splits are {{1 -> NULL}, {2 -> NULL}, {3 -> NULL}, {4 -> NULL}, {NULL}}.

Input:LL: 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8, K = 3Output:{{1, 2, 3}, {4, 5, 6}, {7, 8}}

**Approach:** The given problem can be solved based on the observation that forming first **N % K** groups of size **(N / K + 1)** and the remaining** K – (N % K)** groups of size **N / K** satisfies the conditions. Follow the steps below to solve the problem:

- Initialize a vector of the linked list, says
**ans**, that stores the**K**groups. - Store the value of
**N / K**and**N % K**in the variables, say**L**and**R**. - Traverse the given linked list and perform the following steps:
- Store the value of
**L**in a variable say**X**and the value of**head**in the variable say**currHead**and**last**. - If the value of
**R**is positive, then update the value of**head**to**head->next**. - Iterate a loop until X is non-zero and perform the following steps:
- If the
**last node**is the same as the**head node**then move the**head node**to the next node. - Otherwise, join the links between the
**last node**and the**head node**and update the**last**to head, and move the**head node**to the next node. - Push the current Linked List as the
**currentHead**in the vector**ans[]**.

- If the

- Store the value of
- If the value of
**K**is greater than**0**, then push the NULL Linked List in**ans**and decrement**K**by 1. - After completing the above steps, print the elements of all the Linked List stored in the vector
**ans[]**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `// Link List Node` `struct` `ListNode {` ` ` `int` `val;` ` ` `struct` `ListNode* next;` `};` ` ` `// Function to insert a node` `// into the Linked List` `void` `push(ListNode** head_ref,` ` ` `int` `node_val)` `{` ` ` `// Allocate a new dynamic node` ` ` `ListNode* new_node = ` `new` `ListNode();` ` ` ` ` `// Update new_node->val` ` ` `new_node->val = node_val;` ` ` ` ` `// Stores the head_ref` ` ` `new_node->next = (*head_ref);` ` ` ` ` `// Update (*head_ref)` ` ` `(*head_ref) = new_node;` `}` ` ` `// Fucntion to split the linked list` `// in K groups` `void` `splitListInParts(ListNode* head,` ` ` `int` `K)` `{` ` ` `// Stores the K groups` ` ` `vector<ListNode*> ans;` ` ` ` ` `// If head is NULL` ` ` `if` `(!head) {` ` ` ` ` `// Iterate until K is non-zero` ` ` `while` `(K--)` ` ` `ans.push_back(NULL);` ` ` `}` ` ` ` ` `// Stores the length of the` ` ` `// linked list` ` ` `int` `N = 0;` ` ` ` ` `// Stores the head node of the` ` ` `// linked list` ` ` `ListNode* p = head;` ` ` ` ` `// Iterate over the linked list` ` ` `while` `(p) {` ` ` ` ` `// Update p` ` ` `p = p->next;` ` ` ` ` `// Update N` ` ` `N++;` ` ` `}` ` ` ` ` `int` `len = N / K;` ` ` `int` `rem = N % K;` ` ` ` ` `p = head;` ` ` ` ` `// Iterate over the linked list` ` ` `while` `(K > 0 && p) {` ` ` ` ` `// Stores the length` ` ` `// of the current group` ` ` `int` `x = len;` ` ` ` ` `// Stores the current node` ` ` `ListNode* curr_head = p;` ` ` ` ` `// Stores the previous node` ` ` `ListNode* last = p;` ` ` ` ` `// If rem is greater than 0` ` ` `if` `(rem > 0) {` ` ` ` ` `// Update p` ` ` `p = p->next;` ` ` ` ` `// Decrement rem by 1` ` ` `rem--;` ` ` `}` ` ` ` ` `// Iterate until x is non-zero` ` ` `while` `(x--) {` ` ` ` ` `// If the last is equal to p` ` ` `if` `(last == p)` ` ` `p = p->next;` ` ` ` ` `// Otherwise` ` ` `else` `{` ` ` ` ` `// Join the link between` ` ` `// last and the current` ` ` `// element` ` ` `last->next = p;` ` ` ` ` `// Update the last node` ` ` `last = p;` ` ` ` ` `// Update p node` ` ` `p = p->next;` ` ` `}` ` ` `}` ` ` ` ` `// Assign NULL to last->next` ` ` `last->next = NULL;` ` ` ` ` `// Push the current linked` ` ` `// list in ans` ` ` `ans.push_back(curr_head);` ` ` ` ` `// Decrement K` ` ` `K--;` ` ` `}` ` ` ` ` `// While K greater than 0` ` ` `while` `(K > 0) {` ` ` ` ` `// Update the value of ans` ` ` `ans.push_back(NULL);` ` ` ` ` `// Increment K` ` ` `K--;` ` ` `}` ` ` ` ` `// Print the result` ` ` `cout << ` `"{"` `;` ` ` `for` `(` `int` `i = 0; i < ans.size(); i++) {` ` ` `cout << ` `"{"` `;` ` ` ` ` `while` `(ans[i]) {` ` ` ` ` `// Print the value` ` ` `cout << ans[i]->val << ` `" "` `;` ` ` ` ` `// Update ans[i]` ` ` `ans[i] = ans[i]->next;` ` ` `}` ` ` `cout << ` `"}"` `;` ` ` `if` `(i != ans.size() - 1)` ` ` `cout << ` `", "` `;` ` ` `}` ` ` `cout << ` `"}"` `;` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `ListNode* root = NULL;` ` ` `push(&root, 8);` ` ` `push(&root, 7);` ` ` `push(&root, 6);` ` ` `push(&root, 5);` ` ` `push(&root, 4);` ` ` `push(&root, 3);` ` ` `push(&root, 2);` ` ` `push(&root, 1);` ` ` `int` `K = 3;` ` ` ` ` `splitListInParts(root, K);` ` ` ` ` `return` `0;` `}` |

**Output:**

{{1 2 3 }, {4 5 6 }, {7 8 }}

**Time Complexity:** O(N)**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**