leet25.K 个一组翻转链表

题目：

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

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

 

示例：

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

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

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

 

说明：

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

看到这种反转什么什么，第一念头就是stack。是的，就是那个吃了光吐不拉的数据结构。先进来的最后出去，不就是按照入栈顺序反序了么。
开一个k深度的workStack，存的是ListNode *，我们以k为一个小循环，用prevNode指向入栈第一个元素的前一个元素，出栈时prevNode->next指向出栈第一个元素，出栈第一个指向出栈第二个，出栈第二个指向出栈第三个...
这里我为了处理方便，单独在head前面又开了一个临时变量hair，目的只是为了第一轮的while能和后面的while保持一致，些微的优美一些。
返回时，返回我在3中记录的临时变量的hair>next

源码：

/**
 * 思路一：stack
*/
struct ListNode* reverseKGroup(struct ListNode* head, int k) {
    //工作节点
    struct ListNode* whead = head;
    //指向入栈第一个元素的前一个元素 
    struct ListNode* preNode = NULL;
    //k大小的工作栈用于存放 指针
    struct ListNode** workStack = (struct ListNode*)malloc(k * sizeof(struct ListNode*));
    //为了统一操作添加头节点
    struct ListNode hair = { 0 };
    //头节点 和prevNode初始化
    hair.next = head;
    preNode = &hair;
    //循环链表
    while (whead) {
        //计数器用于统计入栈数量
        int counter = 0;
        //每次循环k个节点入栈
        while (counter < k && whead) {
            workStack[counter++] = whead;
            whead = whead->next;
        }
        //如果栈中元素少于k个，则不需反转
        if (counter != k) break;
        //如满足条件则依次出栈
        while (counter--) {
            //出栈
            preNode->next = workStack[counter];
            //preNode后移
            preNode = preNode->next;
        }
        //将当前链表与尾部链表连在一起
        preNode->next = whead;
    }
    free(workStack);
    return hair.next;

}