【打卡】牛客网：BM3 链表中的节点每k个一组翻转

一、Python

自己写的。

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param head ListNode类
# @param k int整型
# @return ListNode类
#
class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        # write code here
        if head:

            h1 = ListNode(0)
            h1.next = head
            ansHead = h1
            h2 = head

            while h2 is not None:
                # 用test判断是否为最后一组
                test = h2
                flag = 0
                for i in range(k):
                    if test is not None:
                        test = test.next
                    else:
                        flag = 1  # 最后一组没有k个
                        break

                if flag == 0:
                    for i in range(k - 1):  # for i in range(k)是错的

                        h3 = h2.next  # h3是每次要往前提的结点
                        h4 = h3.next  # h4是h3的后一个结点

                        h3.next = h1.next  # h3.next = h1是错的
                        h1.next = h3  # 将h3往前提
                        h2.next = h4

                    # 进入下一组
                    h1 = h2
                    h2 = h1.next

                else:
                    return ansHead.next

            return ansHead.next

 评论中用数组的方法：核心思想是将链表节点值取出放至数组内，在数组内调整各元素位置，最后将调整好位置的元素按顺序赋值给链表各节点。

class Solution:
    def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
        # 创建空列表存放链表节点数值
        var_list = []
        cur = head
        # 遍历链表，将链表节点值取出追加到数组内
        while cur:
            var_list.append(cur.val)
            cur = cur.next
        # 将数组长度对k取商，数组前n*k位元素就是需要调整顺序的，n*k以后的顺序不变
        n = len(var_list)//k
        # 如果列表元素少于k个，直接返回原链表
        if not n:
            return head
        # 调整列表元素顺序
        else:
            for i in range(n):
                for j in range(k):
                    min_index = i*k+j
                    max_index = (i+1)*k-j-1
                    if min_index <= max_index:
                        var_list[min_index],var_list[max_index] = var_list[max_index],var_list[min_index]
        cur = head
        # 将调整好顺序的列表各元素按顺序赋值给链表节点
        while cur :
            cur.val = var_list.pop(0)
            cur = cur.next
        return head

 评论中用递归的方法：额外增加了一个新的链表，而且在考虑最后一组也非常巧妙。

class Solution:
    def reverse(self, head, k):
        p = head
        if head is None:
            return p
        end = ListNode(head.val)
        start = end
        for i in range(1, k):
            if head is None: # 最后一组在这里考虑，非常巧妙
                return p
            if head.next is None:
                return p
            head = head.next
            node = ListNode(head.val)
            node.next = start
            start = node
        end.next = self.reverse(head.next, k)
        return start
 
    def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
        if head is None:
            return head
        start = self.reverse(head, k)
        return start

评论中回复最高的和我的方法类似。

class Solution:
    def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
        # write code here
        res=ListNode(0)
        res.next=head
        pre=res # 指向进行反转部分链表的前序
        cur=head # 指向进行反转部分链表头
        while cur:
            tail=cur
            for i in range(0,k): # 判断要不要翻转
                if tail==None:
                    return res.next
                else: tail=tail.next
            for i in range(1,k): # 翻转
                temp=cur.next
                cur.next=temp.next
                temp.next=pre.next
                pre.next=temp
            cur=cur.next # 指向下一部分列表头
            for i in range(0,k):
                pre=pre.next
        return res.next

二、c++ 

自己写的（与速刷模板不同）：

调试很久的地方：第二个for循环也要循环k次，而不是k-1次。因为每组第一个元素都指向了NULL。

/**
 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 *  ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @param k int整型
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
        // write code here
        ListNode* tail = head;
        for (int i = 0; i < k; i++) {
            if (tail == NULL)
                return head;
            tail = tail -> next;
        }
        ListNode* pre = NULL;
        ListNode* cur = head;
        for (int i = 0; i < k; i++) {
            ListNode* temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        head->next = reverseKGroup(tail, k);
        return pre;
    }
};