給出一個連結串列，每 k 個節點一組進行翻轉，並返回翻轉後的連結串列。

k 是一個正整數，它的值小於或等於連結串列的長度。如果節點總數不是 k 的整數倍，那麼將最後剩餘節點保持原有順序。

示例 :

給定這個連結串列：1->2->3->4->5

當 k = 2 時，應當返回: 2->1->4->3->5

當 k = 3 時，應當返回: 3->2->1->4->5

說明 :

• 你的演算法只能使用常數的額外空間。
• 你不能只是單純的改變節點內部的值，而是需要實際的進行節點交換。

解題思路

關於這個問題，首先我們很容易想到的思路就是通過兩個指標指向一個group

pre                 lat
 h -> 1 -> 2 -> 3 -> 4 -> 5
 k = 3

另外，大家也可以想一想，我們的邊界能不能是[pre, lat]、(pre, lat]、[pre, lat)這樣的呢？這裡的[pre, lat]實際上就是Leetcode 206:反轉連結串列（最詳細解決方案！！！）文章的內容，和這個問題相比，我們這裡有一個不變數pre

接著，我們來看怎麼進行reverse，首先定義兩個指標lpre=pre.next和cur=lpre.next

pre  lpre cur       lat
 h -> 1 -> 2 -> 3 -> 4 -> 5
 k = 3

當cur!=lat的時候我們要做的操作就是lpre.next=cur.next、cur.next=pre.next、pre.next=cur、cur=lpre.next

pre  lpre      cur  lat
      -----------
      |         |
 h    1 <- 2    3
 
 -> 4 -> 5
 |         |
 -----------

我們就可以很容易的寫出這個reverse操作，我們函式_reverseGroup的返回值是lat的前一個node

def _reverseGroup(self, pre, lat):
    lpre = pre.next
    cur = lpre.next
    while cur != lat:
        lpre.next = cur.next
        cur.next = pre.next
        pre.next = cur
        cur = lpre.next

    return lpre

接著我們就要寫整個大迴圈。整個大迴圈結束的條件是cur!=None，然後每k個節點我們做一次reverse，將reverse的結果給pre，接著更新cur=pre.next。如果沒有k個節點的話，我們cur=cur.next即可。

while cur != None:
    if t % k == 0:
        pre = self._reverseGroup(pre, cur.next)
        cur = pre.next
    else:
        cur = cur.next

以下是整個程式碼

class Solution:
    def _reverseGroup(self, pre, lat):
        lpre = pre.next
        cur = lpre.next
        while cur != lat:
            lpre.next = cur.next
            cur.next = pre.next
            pre.next = cur
            cur = lpre.next

        return lpre

    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        h = ListNode(-1)
        h.next = head
        pre = h
        cur = head

        t = 1
        while cur != None:
            if t % k == 0:
                pre = self._reverseGroup(pre, cur.next)
                cur = pre.next
            else:
                cur = cur.next
            t += 1

        return h.next

我們當然可以把這個寫到一個函式中。我們有兩種做法

• 先遍歷一遍連結串列，統計連結串列長度，然後每k個連結串列做反轉操作。
• 遍歷連結串列的過程中，每k個連結串列做反轉操作

class Solution:
    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        h = ListNode(-1)
        h.next = head
        pre = h
        cur = head

        while cur != None:
            t = cur
            count = 1
            while count < k and t != None:
                t = t.next
                count += 1
            if count == k and t != None:             
                for _ in range(k - 1):
                    lat = cur.next
                    cur.next = lat.next
                    lat.next = pre.next
                    pre.next = lat 

                pre = cur
                cur = pre.next
            else:
                break

        return h.next

對於第二種

class Solution:
    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        h = ListNode(-1)
        h.next = head
        pre = h
        cur = head

        while cur != None:
            t = cur
            count = 1
            while count < k and t != None:
                t = t.next
                count += 1
            if count == k and t != None:             
                for _ in range(k - 1):
                    lat = cur.next
                    cur.next = lat.next
                    lat.next = pre.next
                    pre.next = lat 

                pre = cur
                cur = pre.next
            else:
                break

        return h.next

我更喜歡第一種寫法。

如有問題，希望大家指出！！！