Python3程序将双向链表旋转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 使用
打印列表函数。

Python3

# Node of a doubly linked list 
class Node: 
    def __init__(self, next = None, 
                       prev = None, data = None): 
        self.next = next # reference to next node in DLL 
        self.prev = prev # reference to previous node in DLL 
        self.data = data 
  
def push(head, new_data): 
  
    new_node = Node(data = new_data) 
  
    new_node.next = head 
    new_node.prev = None
  
    if head is not None: 
        head.prev = new_node 
  
    head = new_node
    return head
  
def printList(head):
  
    node = head
  
    print("Given linked list")
    while(node is not None): 
        print(node.data, end = " "), 
        last = node 
        node = node.next
      
def rotate(start, N):
    if N == 0 :
        return
  
    # Let us understand the below code 
    # for example N = 2 and 
    # list = a <-> b <-> c <-> d <-> e. 
    current = start 
  
    # current will either point to Nth 
    # or None after this loop. Current 
    # will point to node 'b' in the 
    # above example 
    count = 1
    while count < N and current != None :
        current = current.next
        count += 1
  
    # If current is None, N is greater 
    # than or equal to count of nodes 
    # in linked list. Don't change the 
    # list in this case 
    if current == None :
        return
  
    # current points to Nth node. Store 
    # it in a variable. NthNode points to 
    # node 'b' in the above example 
    NthNode = current 
  
    # current will point to last node 
    # after this loop current will point 
    # to node 'e' in the above example 
    while current.next != None :
        current = current.next
  
    # Change next of last node to previous 
    # head. Next of 'e' is now changed to 
    # node 'a' 
    current.next = start 
  
    # Change prev of Head node to current 
    # Prev of 'a' is now changed to node 'e' 
    start.prev = current 
  
    # Change head to (N+1)th node 
    # head is now changed to node 'c' 
    start = NthNode.next
  
    # Change prev of New Head node to None 
    # Because Prev of Head Node in Doubly 
    # linked list is None 
    start.prev = None
  
    # change next of Nth node to None 
    # next of 'b' is now None 
    NthNode.next = None
  
    return start
  
# Driver Code
if __name__ == "__main__":
    head = None
  
    head = push(head, 'e')
    head = push(head, 'd')
    head = push(head, 'c')
    head = push(head, 'b')
    head = push(head, 'a')
  
    printList(head)
    print("
")
      
    N = 2
    head = rotate(head, N)
  
    printList(head)
  
# This code is contributed by vinayak sharma

输出：

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

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