【leetcode】25. Reverse Nodes in k-Group

/**
 * 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
 */
#include <iostream>
#include <string>
#include <vector>
using namespace std;

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

ListNode* createList(ListNode*head, int num)
{
    ListNode* pl = head;

    ListNode* node = new ListNode(num);
    if (pl == NULL)
    {
        head = node;
    }
    else
    {
        while (pl->next != NULL)
        {
            pl = pl->next;
        }

        pl->next = node;
    }
    return head;
}

ListNode* reverse(ListNode* start, ListNode* end)
{
    ListNode *head = end, *tmp = NULL;
    while (start != end)
    {
        tmp = start->next;
        start->next = head;
        head = start;
        start = tmp;
    }
    return head;
}

//leetcode想法
ListNode* reverseKGroup(ListNode* head, int k)
{
    ListNode *node = head;
    ListNode *rs = NULL;

    for (int i = 0; i < k; i++)
    {
        if (node == NULL) return head;
        node = node->next;
    }

    rs = reverse(head, node);
    head->next = reverseKGroup(node, k);

    return rs;
}

int main()
{

    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };

    ListNode* head = NULL, *rs = NULL;
    for (int i = 0; i < 8; i++)
    {
        head = createList(head, arr[i]);
    }
    rs = reverseKGroup(head, 3);
    while (rs)
    {
        cout << rs->val << "    ";
        rs = rs->next;
    }
    system("pause");
    return 0;
}