leetcode

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

题目大意，按照k来对链表进行分组，然后对每组进行逆序，若该组的结点数比k小，则保持链表不变

个人思路：

1，先计算链表长度，记为length，结合k，可计算出组数group，然后就是对于每组结点做反转

2，对于反转，我设置了3个指针，preGroup指向前一个组的最后一个结点，current指向当前结点，pre指向当前结点的前一个结点，每次循环，都是把current指向的结点插入到preGroup指向的结点之后，直到该组的结点都遍历完

3，重新设置一下这3个指针，继续2的步骤，直到所有组都反转

代码：

#include <stddef.h>

struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if (!head || k < 2)
        {
            return head;
        }

        ListNode dummy(-1);
        dummy.next = head;
        ListNode *current = dummy.next;
        int length = 0;

        while (current)
        {
            current = current->next;
            ++length;
        }

        int group = length / k;
        ListNode *preGroup = &dummy;
        ListNode *pre = &dummy;
        current = dummy.next;

        for (int i = 0; i < group; ++i)
        {
            preGroup = pre;
            pre = current;
            current = current->next;

            for (int j = 0; j < k - 1; ++j)
            {
                pre->next = current->next;
                current->next = preGroup->next;
                preGroup->next = current;

                current = pre->next;
            }
        }

        return dummy.next;
    }
};

看了一下网上的思路，基本差不多（除了递归版的），关于反转，除了把current结点插入到preGroup之后，也可以把current结点插入到nextGroup（下一个组的头结点）之前，也算是拓展一下我的思维方式，防止思维定势