# Append the last M nodes to the beginning of the given linked list.

Last Updated : 22 Mar, 2023

Given a linked list and an integer M, the task is to append the last M nodes of the linked list to the front.
Examples:

Input: List = 4 -> 5 -> 6 -> 1 -> 2 -> 3 -> NULL, M = 3
Output: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL
Input: List = 8 -> 7 -> 0 -> 4 -> 1 -> NULL, M = 2
Output: 4 -> 1 -> 8 -> 7 -> 0 -> NULL

Approach: Find the first node of the last M nodes in the list, this node will be the new head node so make the next pointer of the previous node as NULL and point the last node of the original list to the head of the original list. Finally, print the updated list.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Class for a node of` `// the linked list` `struct` `Node {`   `    ``// Data and the pointer` `    ``// to the next node` `    ``int` `data;` `    ``Node* next;` `    ``Node(``int` `data)` `    ``{` `        ``this``->data = data;` `        ``this``->next = NULL;` `    ``}` `};`   `// Function to print the linked list` `void` `printList(Node* node)` `{` `    ``while` `(node != NULL) {` `        ``cout << (node->data) << ``" -> "``;` `        ``node = node->next;` `    ``}` `    ``cout << ``"NULL"``;` `}`   `// Recursive function to return the` `// count of nodes in the linked list` `int` `cntNodes(Node* node)` `{` `    ``if` `(node == NULL)` `        ``return` `0;`   `    ``return` `(1 + cntNodes(node->next));` `}`   `// Function to update and print` `// the updated list nodes` `void` `updateList(Node* head, ``int` `m)` `{`   `    ``// Total nodes in the list` `    ``int` `cnt = cntNodes(head);`   `    ``if` `(cnt != m && m < cnt) {`   `        ``// Count of nodes to be skipped` `        ``// from the beginning` `        ``int` `skip = cnt - m;` `        ``Node* prev = NULL;` `        ``Node* curr = head;`   `        ``// Skip the nodes` `        ``while` `(skip > 0) {` `            ``prev = curr;` `            ``curr = curr->next;` `            ``skip--;` `        ``}`   `        ``// Change the pointers` `        ``prev->next = NULL;` `        ``Node* tempHead = head;` `        ``head = curr;`   `        ``// Find the last node` `        ``while` `(curr->next != NULL)` `            ``curr = curr->next;`   `        ``// Connect it to the head` `        ``// of the sub list` `        ``curr->next = tempHead;` `    ``}`   `    ``// Print the updated list` `    ``printList(head);` `}`   `// Driver code` `int` `main()` `{`   `    ``// Create the list` `    ``Node* head = ``new` `Node(4);` `    ``head->next = ``new` `Node(5);` `    ``head->next->next = ``new` `Node(6);` `    ``head->next->next->next = ``new` `Node(1);` `    ``head->next->next->next->next = ``new` `Node(2);` `    ``head->next->next->next->next->next = ``new` `Node(3);` `    ``int` `m = 3;` `    ``updateList(head, m);` `    ``return` `0;` `}`   `// This code is contributed by rutvik_56`

## Java

 `// Java implementation of the approach` `class` `GFG {`   `    ``// Class for a node of` `    ``// the linked list` `    ``static` `class` `Node {`   `        ``// Data and the pointer` `        ``// to the next node` `        ``int` `data;` `        ``Node next;`   `        ``Node(``int` `data)` `        ``{` `            ``this``.data = data;` `            ``this``.next = ``null``;` `        ``}` `    ``}`   `    ``// Function to print the linked list` `    ``static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``System.out.print(node.data + ``" -> "``);` `            ``node = node.next;` `        ``}` `        ``System.out.print(``"NULL"``);` `    ``}`   `    ``// Recursive function to return the` `    ``// count of nodes in the linked list` `    ``static` `int` `cntNodes(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return` `0``;`   `        ``return` `(``1` `+ cntNodes(node.next));` `    ``}`   `    ``// Function to update and print` `    ``// the updated list nodes` `    ``static` `void` `updateList(Node head, ``int` `m)` `    ``{`   `        ``// Total nodes in the list` `        ``int` `cnt = cntNodes(head);`   `        ``if` `(cnt != m && m < cnt) {`   `            ``// Count of nodes to be skipped` `            ``// from the beginning` `            ``int` `skip = cnt - m;` `            ``Node prev = ``null``;` `            ``Node curr = head;`   `            ``// Skip the nodes` `            ``while` `(skip > ``0``) {` `                ``prev = curr;` `                ``curr = curr.next;` `                ``skip--;` `            ``}`   `            ``// Change the pointers` `            ``prev.next = ``null``;` `            ``Node tempHead = head;` `            ``head = curr;`   `            ``// Find the last node` `            ``while` `(curr.next != ``null``)` `                ``curr = curr.next;`   `            ``// Connect it to the head` `            ``// of the sub list` `            ``curr.next = tempHead;` `        ``}`   `        ``// Print the updated list` `        ``printList(head);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Create the list` `        ``Node head = ``new` `Node(``4``);` `        ``head.next = ``new` `Node(``5``);` `        ``head.next.next = ``new` `Node(``6``);` `        ``head.next.next.next = ``new` `Node(``1``);` `        ``head.next.next.next.next = ``new` `Node(``2``);` `        ``head.next.next.next.next.next = ``new` `Node(``3``);`   `        ``int` `m = ``3``;`   `        ``updateList(head, m);` `    ``}` `}`

## Python3

 `# Python3 implementation of the approach`   `# Class for a node of` `# the linked list`     `class` `newNode:`   `    ``# Constructor to initialize the node object` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`   `# Function to print the linked list`     `def` `printList(node):`   `    ``while` `(node !``=` `None``):` `        ``print``(node.data, ``"->"``, end``=``" "``)` `        ``node ``=` `node.``next` `    ``print``(``"NULL"``)`   `# Recursive function to return the` `# count of nodes in the linked list`     `def` `cntNodes(node):` `    ``if` `(node ``=``=` `None``):` `        ``return` `0`   `    ``return` `(``1` `+` `cntNodes(node.``next``))`   `# Function to update and print` `# the updated list nodes`     `def` `updateList(head, m):`   `    ``# Total nodes in the list` `    ``cnt ``=` `cntNodes(head)`   `    ``if` `(cnt !``=` `m ``and` `m < cnt):`   `        ``# Count of nodes to be skipped` `        ``# from the beginning` `        ``skip ``=` `cnt ``-` `m` `        ``prev ``=` `None`   `        ``curr ``=` `head`   `        ``# Skip the nodes` `        ``while` `(skip > ``0``):` `            ``prev ``=` `curr` `            ``curr ``=` `curr.``next` `            ``skip ``-``=` `1`   `        ``# Change the pointers` `        ``prev.``next` `=` `None` `        ``tempHead ``=` `head` `        ``head ``=` `curr`   `        ``# Find the last node` `        ``while` `(curr.``next` `!``=` `None``):` `            ``curr ``=` `curr.``next`   `        ``# Connect it to the head` `        ``# of the sub list` `        ``curr.``next` `=` `tempHead`   `    ``# Print the updated list` `    ``printList(head)`   `# Driver code`     `# Create the list` `head ``=` `newNode(``4``)` `head.``next` `=` `newNode(``5``)` `head.``next``.``next` `=` `newNode(``6``)` `head.``next``.``next``.``next` `=` `newNode(``1``)` `head.``next``.``next``.``next``.``next` `=` `newNode(``2``)` `head.``next``.``next``.``next``.``next``.``next` `=` `newNode(``3``)`   `m ``=` `3`   `updateList(head, m)`   `# This code is contributed by shubhamsingh10`

## C#

 `// C# implementation of the approach` `using` `System;`   `class` `GFG {`   `    ``// Class for a node of` `    ``// the linked list` `    ``class` `Node {`   `        ``// Data and the pointer` `        ``// to the next node` `        ``public` `int` `data;` `        ``public` `Node next;`   `        ``public` `Node(``int` `data)` `        ``{` `            ``this``.data = data;` `            ``this``.next = ``null``;` `        ``}` `    ``}`   `    ``// Function to print the linked list` `    ``static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``Console.Write(node.data + ``" -> "``);` `            ``node = node.next;` `        ``}` `        ``Console.Write(``"NULL"``);` `    ``}`   `    ``// Recursive function to return the` `    ``// count of nodes in the linked list` `    ``static` `int` `cntNodes(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return` `0;`   `        ``return` `(1 + cntNodes(node.next));` `    ``}`   `    ``// Function to update and print` `    ``// the updated list nodes` `    ``static` `void` `updateList(Node head, ``int` `m)` `    ``{`   `        ``// Total nodes in the list` `        ``int` `cnt = cntNodes(head);`   `        ``if` `(cnt != m && m < cnt) {`   `            ``// Count of nodes to be skipped` `            ``// from the beginning` `            ``int` `skip = cnt - m;` `            ``Node prev = ``null``;` `            ``Node curr = head;`   `            ``// Skip the nodes` `            ``while` `(skip > 0) {` `                ``prev = curr;` `                ``curr = curr.next;` `                ``skip--;` `            ``}`   `            ``// Change the pointers` `            ``prev.next = ``null``;` `            ``Node tempHead = head;` `            ``head = curr;`   `            ``// Find the last node` `            ``while` `(curr.next != ``null``)` `                ``curr = curr.next;`   `            ``// Connect it to the head` `            ``// of the sub list` `            ``curr.next = tempHead;` `        ``}`   `        ``// Print the updated list` `        ``printList(head);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{`   `        ``// Create the list` `        ``Node head = ``new` `Node(4);` `        ``head.next = ``new` `Node(5);` `        ``head.next.next = ``new` `Node(6);` `        ``head.next.next.next = ``new` `Node(1);` `        ``head.next.next.next.next = ``new` `Node(2);` `        ``head.next.next.next.next.next = ``new` `Node(3);`   `        ``int` `m = 3;`   `        ``updateList(head, m);` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

`1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL`

METHOD 2:

We Will use modification of runner’s technique :-

1. find the kth node from end using runner technique and do the following modifications

2. now we have to update our pointers as

a) fast->next will be pointing to head,

c)last node will be the slow->next hence it should point to null

## C++

 `#include `   `using` `namespace` `std;`   `struct` `node {`   `    ``int` `data;`   `    ``node* next;`   `    ``node(``int` `x)` `    ``{`   `        ``data = x;`   `        ``next = NULL;` `    ``}` `};`   `void` `insertAtTail(node*& head, ``int` `x)` `{`   `    ``if` `(head == NULL) {`   `        ``head = ``new` `node(x);`   `        ``return``;` `    ``}`   `    ``node* curr = head;`   `    ``while` `(curr->next != NULL) {`   `        ``curr = curr->next;` `    ``}`   `    ``node* t = ``new` `node(x);`   `    ``curr->next = t;` `}`   `void` `print(node* head)` `{`   `    ``node* curr = head;`   `    ``while` `(curr != NULL) {`   `        ``cout << curr->data << ``" -> "``;`   `        ``curr = curr->next;` `    ``}` `    ``cout << ``"NULL\n"``;` `}`   `node* appendK(node* head, ``int` `k)` `{`   `    ``node* fast = head;`   `    ``node* slow = head;`   `    ``for` `(``int` `i = 0; i < k; i++) {`   `        ``fast = fast->next;` `    ``}`   `    ``while` `(fast->next != NULL) {`   `        ``slow = slow->next;`   `        ``fast = fast->next;` `    ``}`   `    ``// cout<<"data"<<" "<data<<" "<data<next = head;`   `    ``head = slow->next;`   `    ``slow->next = NULL;`   `    ``return` `head;` `}`   `int` `main()` `{`   `    ``node* head = NULL;`   `    ``int` `n;` `    ``n = 6;`   `    ``insertAtTail(head, 4);` `    ``insertAtTail(head, 5);` `    ``insertAtTail(head, 6);` `    ``insertAtTail(head, 1);` `    ``insertAtTail(head, 2);` `    ``insertAtTail(head, 3);`   `    ``int` `k;`   `    ``k = 3;`   `    ``head = appendK(head, k % n);`   `    ``print(head);`   `    ``return` `0;` `}`

## Java

 `// Java code to the above approach`   `import` `java.io.*;`   `class` `GFG {`   `    ``class` `Node {` `        ``int` `data;` `        ``Node next;` `        ``Node(``int` `x)` `        ``{` `            ``data = x;` `            ``next = ``null``;` `        ``}` `    ``}`   `    ``public` `Node insertAtTail(Node head, ``int` `x)` `    ``{` `        ``if` `(head == ``null``) {` `            ``head = ``new` `Node(x);` `            ``return` `head;` `        ``}` `        ``Node curr = head;` `        ``while` `(curr.next != ``null``) {` `            ``curr = curr.next;` `        ``}` `        ``Node t = ``new` `Node(x);` `        ``curr.next = t;` `        ``return` `head;` `    ``}`   `    ``public` `void` `print(Node head)` `    ``{` `        ``Node curr = head;` `        ``while` `(curr != ``null``) {` `            ``System.out.print(curr.data + ``" -> "``);` `            ``curr = curr.next;` `        ``}` `        ``System.out.print(``"NULL\n"``);` `    ``}`   `    ``public` `Node appendK(Node head, ``int` `k)` `    ``{` `        ``Node fast = head;` `        ``Node slow = head;`   `        ``for` `(``int` `i = ``0``; i < k; i++) {` `            ``fast = fast.next;` `        ``}` `        ``while` `(fast.next != ``null``) {` `            ``slow = slow.next;` `            ``fast = fast.next;` `        ``}` `        ``fast.next = head;` `        ``head = slow.next;` `        ``slow.next = ``null``;` `        ``return` `head;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``GFG l = ``new` `GFG();`   `        ``Node head = ``null``;`   `        ``int` `n = ``6``;`   `        ``head = l.insertAtTail(head, ``4``);` `        ``head = l.insertAtTail(head, ``5``);` `        ``head = l.insertAtTail(head, ``6``);` `        ``head = l.insertAtTail(head, ``1``);` `        ``head = l.insertAtTail(head, ``2``);` `        ``head = l.insertAtTail(head, ``3``);`   `        ``int` `k = ``3``;`   `        ``head = l.appendK(head, k % n);` `        ``l.print(head);` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## Python3

 `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`   `class` `LinkedList:` `    ``def` `insertAtTail(``self``, head, x):` `        ``if` `head ``is` `None``:` `            ``head ``=` `Node(x)` `            ``return` `head` `        ``curr ``=` `head` `        ``while` `curr.``next` `is` `not` `None``:` `            ``curr ``=` `curr.``next` `        ``t ``=` `Node(x)` `        ``curr.``next` `=` `t` `        ``return` `head`   `    ``def` `printList(``self``, head):` `        ``curr ``=` `head` `        ``while` `curr ``is` `not` `None``:` `            ``print``(curr.data, end``=``" -> "``)` `            ``curr ``=` `curr.``next` `        ``print``(``"NULL"``)`   `    ``def` `appendK(``self``, head, k):` `        ``fast ``=` `head` `        ``slow ``=` `head`   `        ``for` `i ``in` `range``(k):` `            ``fast ``=` `fast.``next` `        ``while` `fast.``next` `is` `not` `None``:` `            ``slow ``=` `slow.``next` `            ``fast ``=` `fast.``next` `        ``fast.``next` `=` `head` `        ``head ``=` `slow.``next` `        ``slow.``next` `=` `None` `        ``return` `head`   `if` `__name__ ``=``=` `"__main__"``:` `    ``l ``=` `LinkedList()` `    ``head ``=` `None` `    ``n ``=` `6` `    ``head ``=` `l.insertAtTail(head, ``4``)` `    ``head ``=` `l.insertAtTail(head, ``5``)` `    ``head ``=` `l.insertAtTail(head, ``6``)` `    ``head ``=` `l.insertAtTail(head, ``1``)` `    ``head ``=` `l.insertAtTail(head, ``2``)` `    ``head ``=` `l.insertAtTail(head, ``3``)` `    ``k ``=` `3` `    ``head ``=` `l.appendK(head, k ``%` `n)` `    ``l.printList(head)`

## Javascript

 `// JavaScript code to the above approach` `class Node {` `    `  `    ``constructor(x){` `        ``this``.data = x;` `        ``this``.next  = ``null``;` `    ``}`   `}`   `function` `insertAtTail( head,  x)` `{` `    ``if` `(head == ``null``) {` `        ``head = ``new` `Node(x);` `        ``return` `head;` `    ``}` `    ``let curr = head;` `    ``while` `(curr.next != ``null``) {` `        ``curr = curr.next;` `    ``}` `    ``let t = ``new` `Node(x);` `    ``curr.next = t;` `    ``return` `head;` `}`   `function` `print(head)` `{` `    ``let curr = head;` `    ``while` `(curr != ``null``) {` `        ``process.stdout.write(curr.data + ``" -> "``);` `        ``curr = curr.next;` `    ``}` `    ``console.log(``"NULL"``);` `}`   `function` `appendK(head, k)` `{` `    ``let fast = head;` `    ``let slow = head;`   `    ``for` `(let i = 0; i < k; i++) {` `        ``fast = fast.next;` `    ``}` `    ``while` `(fast.next != ``null``) {` `        ``slow = slow.next;` `        ``fast = fast.next;` `    ``}` `    ``fast.next = head;` `    ``head = slow.next;` `    ``slow.next = ``null``;` `    ``return` `head;` `}`       `let head = ``null``;`   `let n = 6;`   `head = insertAtTail(head, 4);` `head = insertAtTail(head, 5);` `head = insertAtTail(head, 6);` `head = insertAtTail(head, 1);` `head = insertAtTail(head, 2);` `head = insertAtTail(head, 3);`   `let k = 3;`   `head = appendK(head, k % n);` `print(head);`   `// This code is contributed by Nidhi goel.`

## C#

 `// C# code to the above approach` `using` `System;`   `public` `class` `GFG {`   `  ``class` `Node {` `    ``public` `int` `data;` `    ``public` `Node next;` `    ``public` `Node(``int` `x)` `    ``{` `      ``data = x;` `      ``next = ``null``;` `    ``}` `  ``}`   `  ``Node insertAtTail(Node head, ``int` `x)` `  ``{` `    ``if` `(head == ``null``) {` `      ``head = ``new` `Node(x);` `      ``return` `head;` `    ``}` `    ``Node curr = head;` `    ``while` `(curr.next != ``null``) {` `      ``curr = curr.next;` `    ``}` `    ``Node t = ``new` `Node(x);` `    ``curr.next = t;` `    ``return` `head;` `  ``}`   `  ``void` `print(Node head)` `  ``{` `    ``Node curr = head;` `    ``while` `(curr != ``null``) {` `      ``Console.Write(curr.data + ``" -> "``);` `      ``curr = curr.next;` `    ``}` `    ``Console.Write(``"NULL\n"``);` `  ``}`   `  ``Node appendK(Node head, ``int` `k)` `  ``{` `    ``Node fast = head;` `    ``Node slow = head;`   `    ``for` `(``int` `i = 0; i < k; i++) {` `      ``fast = fast.next;` `    ``}` `    ``while` `(fast.next != ``null``) {` `      ``slow = slow.next;` `      ``fast = fast.next;` `    ``}` `    ``fast.next = head;` `    ``head = slow.next;` `    ``slow.next = ``null``;` `    ``return` `head;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``GFG l = ``new` `GFG();`   `    ``Node head = ``null``;`   `    ``int` `n = 6;`   `    ``head = l.insertAtTail(head, 4);` `    ``head = l.insertAtTail(head, 5);` `    ``head = l.insertAtTail(head, 6);` `    ``head = l.insertAtTail(head, 1);` `    ``head = l.insertAtTail(head, 2);` `    ``head = l.insertAtTail(head, 3);`   `    ``int` `k = 3;`   `    ``head = l.appendK(head, k % n);` `    ``l.print(head);` `  ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

Output

`1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL`

Time complexity: O(n) where n is size of given linked list

Previous
Next