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

23 Dec, 2021
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 -> NULLInput: 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++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Class for a node of// the linked liststruct 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 listvoid 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 listint cntNodes(Node* node){    if (node == NULL)        return 0;     return (1 + cntNodes(node->next));} // Function to update and print// the updated list nodesvoid 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 codeint 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 implementation of the approachclass 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 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 listhead = 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# implementation of the approachusing 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
<script>      // JavaScript implementation of the approach      // Class for a node of      // the linked list      class Node {        // Data and the pointer        // to the next node         constructor(data) {          this.data = data;          this.next = null;        }      }       // Function to print the linked list      function printList(node) {        while (node != null) {          document.write(node.data + " -> ");          node = node.next;        }        document.write("NULL");      }       // Recursive function to return the      // count of nodes in the linked list      function cntNodes(node) {        if (node == null) return 0;         return 1 + cntNodes(node.next);      }       // Function to update and print      // the updated list nodes      function updateList(head, m) {        // Total nodes in the list        var cnt = cntNodes(head);         if (cnt != m && m < cnt) {          // Count of nodes to be skipped          // from the beginning          var skip = cnt - m;          var prev = null;          var curr = head;           // Skip the nodes          while (skip > 0) {            prev = curr;            curr = curr.next;            skip--;          }           // Change the pointers          prev.next = null;          var 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      // Create the list      var 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);       var m = 3;       updateList(head, m);             // This code is contributed by rdtank.    </script>
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL
METHOD 2:
We Will use modififcation 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,
b)slow->next will be new head,
c)last node will be the slow->next hence it should point to null
C++
#include <iostream> 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"<<" "<<slow->data<<" "<<fast->data<<endl;     fast->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;}
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL

princiraj1992
SHUBHAMSINGH10
Code_Mech
rutvik_56
rdtank
darkthunderassassin
Data Structures
Linked List
Data Structures
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Data Structures | Queue | Question 11
Multilevel Linked List
Program to create Custom Vector Class in C++
Data Structures | Stack | Question 4
Count of triplets in an Array (i, j, k) such that i < j < k and a[k] < a[i] < a[j]
Linked List | Set 1 (Introduction)
Linked List | Set 2 (Inserting a node)
Reverse a linked list
Stack Data Structure (Introduction and Program)
Linked List | Set 3 (Deleting a node)