Java程序将双向链表旋转N个节点

给定一个双向链表，将链表逆时针旋转 N 个节点。这里 N 是给定的正整数，并且小于链表中的节点数。

N = 2
轮换名单：

例子：

Input : a  b  c  d  e   N = 2
Output : c  d  e  a  b 

Input : a  b  c  d  e  f  g  h   N = 4
Output : e  f  g  h  a  b  c  d 

在亚马逊上问

要旋转双向链表，我们需要将第 N 个节点的下一个节点更改为 NULL，将最后一个节点的下一个节点更改为前一个头节点，将头节点的 prev 更改为最后一个节点，最后将 head 更改为第 (N+1) 个节点和 prev新的头节点为 NULL（双向链表中头节点的上一个为 NULL）
所以我们需要掌握三个节点：第 N 个节点、第 (N+1) 个节点和最后一个节点。从开始遍历列表并在第 N 个节点处停止。存储指向第 N 个节点的指针。我们可以使用 NthNode->next 获得第 (N+1) 个节点。继续遍历直到结束并存储指向最后一个节点的指针。最后，如上所述更改指针，并在 Last Print Rotated List 使用
打印列表函数。

Java

// Java program to rotate a Doubly linked 
// list counter clock wise by N times 
class GfG { 
  
/* Link list node */
static class Node
{ 
    char data; 
    Node prev; 
    Node next; 
}
static Node head = null;
  
// This function rotates a doubly linked 
// list counter-clockwise and updates the 
// head. The function assumes that N is 
// smallerthan size of linked list. It 
// doesn't modify the list if N is greater 
// than or equal to size 
static void rotate( int N) 
{ 
    if (N == 0) 
        return; 
  
    // Let us understand the below code 
    // for example N = 2 and 
    // list = a <-> b <-> c <-> d <-> e. 
    Node current = head; 
  
    // current will either point to Nth 
    // or NULL after this loop. Current 
    // will point to node 'b' in the 
    // above example 
    int count = 1; 
    while (count < N && current != null)
    { 
        current = current.next; 
        count++; 
    } 
  
    // If current is NULL, N 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 Nth node. Store 
    // it in a variable. NthNode points to 
    // node 'b' in the above example 
    Node NthNode = current; 
  
    // current will point to last node 
    // after this loop current will point 
    // to node 'e' in the above example 
    while (current.next != null) 
        current = current.next; 
  
    // Change next of last node to previous 
    // head. Next of 'e' is now changed to 
    // node 'a' 
    current.next = head; 
  
    // Change prev of Head node to current 
    // Prev of 'a' is now changed to node 'e' 
    (head).prev = current; 
  
    // Change head to (N+1)th node 
    // head is now changed to node 'c' 
    head = NthNode.next; 
  
    // Change prev of New Head node to NULL 
    // Because Prev of Head Node in Doubly 
    // linked list is NULL 
    (head).prev = null; 
  
    // change next of Nth node to NULL 
    // next of 'b' is now NULL 
    NthNode.next = null; 
} 
  
// Function to insert a node at the 
// beginning of the Doubly Linked List 
static void push(char new_data) 
{ 
    Node new_node = new Node(); 
    new_node.data = new_data; 
    new_node.prev = null; 
    new_node.next = (head); 
    if ((head) != null) 
        (head).prev = new_node; 
head = new_node; 
} 
  
/* Function to print linked list */
static void printList(Node node) 
{ 
    while (node != null && node.next != null)
    { 
        System.out.print(node.data + " "); 
        node = node.next; 
    } 
    if(node != null)
    System.out.print(node.data); 
} 
  
// Driver's Code 
public static void main(String[] args) 
{ 
    /* Start with the empty list */
    // Node head = null; 
  
    /* Let us create the doubly 
    linked list a<->b<->c<->d<->e */
    push( 'e'); 
    push( 'd'); 
    push('c'); 
    push('b'); 
    push( 'a'); 
  
    int N = 2; 
  
    System.out.println("Given linked list "); 
    printList(head); 
    rotate( N); 
    System.out.println();
    System.out.println("Rotated Linked list "); 
    printList(head); 
} 
} 
  
// This code is contributed by Prerna Saini

输出：

Given linked list 
a  b  c  d  e
Rotated Linked list 
c  d  e  a  b

更多详细信息请参考完整文章旋转 N 个节点的双向链表！