用于旋转链表的Java程序

给定一个单链表，将链表逆时针旋转 k 个节点。其中 k 是给定的正整数。例如，如果给定的链表是 10->20->30->40->50->60，k 为 4，则链表应修改为 50->60->10->20->30- >40。假设 k 小于链表中的节点数。

方法一：
要旋转链表，我们需要将第 k 个节点的 next 更改为 NULL，将最后一个节点的 next 更改为前一个 head 节点，最后将 head 更改为第 (k+1) 个节点。所以我们需要掌握三个节点：第k个节点、第(k+1)个节点和最后一个节点。
从头开始遍历列表并在第 k 个节点处停止。存储指向第 k 个节点的指针。我们可以使用 kthNode->next 获得第 (k+1) 个节点。继续遍历直到结束并存储指向最后一个节点的指针。最后，如上所述更改指针。

下图显示了如何在代码中使用旋转函数：

Java

// Java program to rotate a 
// linked list
class LinkedList 
{
    // Head of list
    Node head; 
  
    // Linked list Node
    class Node 
    {
        int data;
        Node next;
        Node(int d)
        {
            data = d;
            next = null;
        }
    }
  
    // This function rotates a linked list 
    // counter-clockwise and updates the 
    // head. The function assumes that k is
    // smaller than size of linked list. It 
    // doesn't modify the list if k is greater 
    // than or equal to size
    void rotate(int k)
    {
        if (k == 0)
            return;
  
        // Let us understand the below code 
        // for example k = 4 and list = 
        // 10->20->30->40->50->60.
        Node current = head;
  
        // current will either point to kth or 
        // NULL after this loop. current will 
        // point to node 40 in the above example
        int count = 1;
        while (count < k && current != null) 
        {
            current = current.next;
            count++;
        }
  
        // If current is NULL, k is greater than 
        // or equal to count of nodes in linked list. 
        // Don't change the list in this case
        if (current == null)
            return;
  
        // current points to kth node. Store it in a 
        // variable. kthNode points to node 40 in the
        // above example
        Node kthNode = current;
  
        // current will point to last node after this 
        // loop current will point to node 60 in the 
        // above example
        while (current.next != null)
            current = current.next;
  
        // Change next of last node to previous head
        // Next of 60 is now changed to node 10
  
        current.next = head;
  
        // Change head to (k+1)th node
        // head is now changed to node 50
        head = kthNode.next;
  
        // change next of kth node to null
        kthNode.next = null;
    }
  
    /*  Given a reference (pointer to pointer) 
        to the head of a list and an int, push
        a new node on the front of the list. */
    void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);
  
        // 3. Make next of new Node as head 
        new_node.next = head;
  
        // 4. Move the head to point to 
        // new Node 
        head = new_node;
    }
  
    void printList()
    {
        Node temp = head;
        while (temp != null) 
        {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }
  
    // Driver code
    public static void main(String args[])
    {
        LinkedList llist = new LinkedList();
  
        // Create a list 
        // 10->20->30->40->50->60
        for (int i = 60; i >= 10; i -= 10)
            llist.push(i);
  
        System.out.println(
               "Given list");
        llist.printList();
  
        llist.rotate(4);
  
        System.out.println(
               "Rotated Linked List");
        llist.printList();
    }
}
// This code is contributed by Rajat Mishra

输出：

Given linked list
10  20  30  40  50  60
Rotated Linked list
50  60  10  20  30  40

方法二：
要将链表旋转k，我们可以先使链表循环，然后从头节点向前移动k-1步，使第(k-1)个节点的next为空，并以第k个节点为头。

Java

// Java program to rotate a 
// linked list counter clock wise
import java.util.*;
  
class GFG{
  
// Link list node 
static class Node 
{
    int data;
    Node next;
};
static  Node head = null;
    
// This function rotates a linked list
// counter-clockwise and updates the
// head. The function assumes that k is
// smaller than size of linked list.
static void rotate( int k)
{
    if (k == 0)
        return;
  
    // Let us understand the below
    // code for example k = 4 and
    // list = 10.20.30.40.50.60.
    Node current = head;
  
    // Traverse till the end.
    while (current.next != null)
        current = current.next;
  
    current.next = head;
    current = head;
  
    // Traverse the linked list to 
    // k-1 position which will be 
    // last element for rotated array.
    for (int i = 0; i < k - 1; i++)
        current = current.next;
  
    // Update the head_ref and last 
    // element pointer to null
    head = current.next;
    current.next = null;
}
  
// UTILITY FUNCTIONS 
// Function to push a node 
static void push(int new_data)
{  
    // Allocate node 
    Node new_node = new Node();
  
    // Put in the data 
    new_node.data = new_data;
  
    // Link the old list off the 
    // new node 
    new_node.next = head;
  
    // Move the head to point to 
    // the new node
    head = new_node;
}
  
// Function to print linked list 
static void printList(Node node)
{
    while (node != null)
    {
        System.out.print(node.data + " ");
        node = node.next;
    }
}
  
// Driver code
public static void  main(String[] args)
{
    // Start with the empty list
    // Create a list 10.20.30.40.50.60
    for (int i = 60; i > 0; i -= 10)
        push(i);
  
    System.out.print(
           "Given linked list ");
    printList(head);
    rotate( 4);
  
    System.out.print(
           "Rotated Linked list ");
    printList(head);
}
}
// This code is contributed by gauravrajput1 

输出：

Given linked list 
10 20 30 40 50 60 
Rotated Linked list 
50 60 10 20 30 40

有关详细信息，请参阅有关旋转链接列表的完整文章！