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

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:

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
    }
}

chevron_right






                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 



















                        chevron_right







                        filter_none











Output:


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







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
    

    

        
        

            
            
        

    


Recommended Posts:
mishrakishan1
Check out this Author's contributed articles.
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 Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.