LeetCode25-k个一组翻转链表

今天上午被LeetCode30题搞得快要崩溃了

好不容易写出个解法

还给我来个超出时间限制

吐了不止一碗血！！！

本来之前还是自信满满的以为算法能力提高了

今天算是彻底让我认清了现实

哭泣一分钟！

---

25-k个一组翻转链表

给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 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%左右。