力扣热题100 - 腾讯常见面试题 - 链表：K个一组反转链表

题目描述：

题号：25

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

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

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

解题思路：

思路一：切分+反转

算法思路：

利用反转链表一题中的函数。

先将链表拆分再反转，然后递归下一段 K 个节点长的链表，直到最后一段链表长度不足 K 个。

时间复杂度：O(N)

空间复杂度：O(1)

C++

// C++
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* temp = head;
        for(int i = 1; temp != nullptr && i < k; i++ ){
            temp = temp->next;
        }

        if(temp == nullptr){
            return head;
        }

        // 切分链表
        ListNode* mid = temp->next;
        temp->next = nullptr;

        ListNode* newHead = reverseList(head);

        ListNode* newTemp = reverseKGroup(mid, k);

        head->next = newTemp;
        return newHead;
    }

    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode *cur = head, *pre = nullptr;
        while(cur != nullptr) {
            ListNode *temp = cur->next;
            // 使当前节点指向前一个节点
            cur->next = pre;
            // 准备处理下一个节点
            // 两指针都向前移动一个元素
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

go

// go
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseKGroup(head *ListNode, k int) *ListNode {
    temp := head
    for i := 1; temp != nil && i < k; i++ {
        temp = temp.Next
    }

    if temp == nil {
        return head
    }

    t := temp.Next
    temp.Next = nil

    newHead := reverseList(head)

    newTemp := reverseKGroup(t, k)

    head.Next = newTemp
    return newHead
}

func reverseList(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    var pre *ListNode
    cur := head
    for cur != nil {
        temp := cur.Next
        // 使当前指针指向它的前一个节点
        cur.Next = pre
        // 两指针都向前移动一个元素
        pre = cur
        cur = temp
    }
    return pre
}