用于反转给定大小组中的链表的Python程序集 2

给定一个链表，编写一个函数来反转每 k 个节点（其中 k 是函数的输入）。
例子：

Input: 1->2->3->4->5->6->7->8->NULL and k = 3 
Output: 3->2->1->6->5->4->8->7->NULL. 

Input: 1->2->3->4->5->6->7->8->NULL and k = 5
Output: 5->4->3->2->1->8->7->6->NULL.

我们已经在下面的帖子中讨论了它的解决方案
在给定大小的组中反转链接列表 |设置 1
在这篇文章中，我们使用了一个堆栈来存储给定链表的节点。首先，将链表的 k 个元素压入栈中。现在一个一个地弹出元素并跟踪之前弹出的节点。将 prev 节点的 next 指针指向栈顶元素。重复此过程，直到达到 NULL。
该算法使用 O(k) 额外空间。

Python3

# Python3 program to reverse a Linked List
# in groups of given size
  
# Node class
class Node(object):
    __slots__ = 'data', 'next'
  
    # Constructor to initialize the 
    # node object
    def __init__(self, data = None, 
                 next = None):
        self.data = data
        self.next = next
  
    def __repr__(self):
        return repr(self.data)
  
class LinkedList(object):
  
    # Function to initialize head
    def __init__(self):
        self.head = None
  
    # Utility function to print 
    # nodes of LinkedList
    def __repr__(self):
        nodes = []
        curr = self.head
        while curr:
            nodes.append(repr(curr))
            curr = curr.next
        return '[' + ', '.join(nodes) + ']'
  
    # Function to insert a new node at
    # the beginning
    def prepend(self, data):
        self.head = Node(data = data,
                         next = self.head)
  
    # Reverses the linked list in groups 
    # of size k and returns the pointer 
    # to the new head node.
    def reverse(self, k = 1):
        if self.head is None:
            return
  
        curr = self.head
        prev = None
        new_stack = []
        while curr is not None:
            val = 0
              
            # Terminate the loop whichever 
            # comes first either current == None 
            # or value >= k
            while curr is not None and val < k:
                new_stack.append(curr.data)
                curr = curr.next
                val += 1
  
            # Now pop the elements of stack one 
            # by one
            while new_stack:
                  
                # If final list has not been 
                # started yet.
                if prev is None:
                    prev = Node(new_stack.pop())
                    self.head = prev
                else:
                    prev.next = Node(new_stack.pop())
                    prev = prev.next
                      
        # Next of last element will point to None.
        prev.next = None
        return self.head
  
# Driver Code
llist = LinkedList() 
llist.prepend(9)
llist.prepend(8)
llist.prepend(7)
llist.prepend(6)
llist.prepend(5)
llist.prepend(4)
llist.prepend(3)
llist.prepend(2)
llist.prepend(1)
  
print("Given linked list")
print(llist)
llist.head = llist.reverse(3)
  
print("Reversed Linked list")
print(llist)
# This code is contributed by Sagar Kumar Sinha(sagarsinha7777)

输出：

Given Linked List
1 2 3 4 5 6 7 8 9 
Reversed list
3 2 1 6 5 4 9 8 7

请参阅完整的文章在给定大小的组中反转链接列表 |设置2了解更多详情！