将最后 M 个节点附加到给定链表的开头

给定一个链表和一个整数M ，任务是将链表的最后M 个节点追加到前面。
例子：

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 
 

方法：找到链表中最后M个节点的第一个节点，该节点将成为新的头节点，因此将前一个节点的next指针设为NULL，将原链表的最后一个节点指向原链表的头部.最后，打印更新的列表。
下面是上述方法的实现：

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

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

输出：

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。