今天上午被LeetCode30題搞得快要崩潰了

好不容易寫出個解法

還給我來個超出時間限制

吐了不止一碗血！！！

本來之前還是自信滿滿的以為演算法能力提高了

今天算是徹底讓我認清了現實

哭泣一分鐘！

25-k個一組翻轉連結串列

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

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

示例 :

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

當 k 

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

說明 :

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

這一題和上一題兩兩交換連結串列中的節點極其類似，我的解法其實也是借鑑了上題的思想，因為k是個未知量，所以我們可以每次將k個節點對應的值儲存在一個list數組裡，然後用reverse()方法翻轉，最後再將這個數組裡面的值依次賦值給新建的ListNode連結串列，即可得出答案。

程式碼如下：

class Solution:
    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        if head is None:
            return []
        head_list = []
        head_list_copy = []
        head_copy = head
        while head_copy:
            head_list.append(head_copy.val)
            head_copy = head_copy.next
        index_k = k
        while index_k <= len(head_list):
            start = index_k-k
            end = index_k
            h = head_list[start:end]
            h.reverse()
            head_list_copy.extend(h)
            index_k += k
        interval = len(head_list) - (index_k - k)
        if interval > 0:
            head_list_copy.extend(head_list[-interval:])
        Head = ListNode(0)
        head_copy = Head
        for index in head_list_copy:
            head_copy.next = ListNode(index)
            head_copy = head_copy.next
        return Head.next


if __name__ == '__main__':
    l1 = ListNode(0)
    l1_copy = l1
    l1_num = [1, 2, 3, 4, 5]
    for num in l1_num:
        l1_copy.next = ListNode(num)
        l1_copy = l1_copy.next
    k = 2
    result = Solution().reverseKGroup(l1.next, k)
    while result:
        print(result.val)
        result = result.next
 

我覺得我的演算法思想還是比較容易理解，但奈何執行效率一般般，平均在30%左右。