leetcode 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
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。

題解：

首先實現鏈表反轉函數。然後沒找到k個節點，進行反轉。

參考代碼：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        //特殊情況：NULL或僅有一個節點
        if(head == nullptr || head->next == nullptr)
            return head;

        //虛擬頭結點
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;

        //next指向當前結點的下一個結點
        ListNode *next = head;
        //pre_tail指向上一段鏈表的尾節點，初始值爲空指針
        ListNode *pre_tail = nullptr;
        //每一個段的頭結點
        ListNode *newHead = head;
        //計數值，當count增加到k時，就斷鏈，倒置，掛鏈
        int count = 0;

        while(head){
            count++;
            next = head->next;
            if(count == k){
                //斷鏈，並且將該小段鏈表送入倒置函數中
                head->next = nullptr;
                HeadTail headTail = reverse(newHead);

                //掛鏈：處理倒置後的鏈表的頭和尾，巧妙利用pre初始值是否爲空
                if(pre_tail)
                    //不爲空，則上一段鏈表尾節點指向新置鏈表頭結點
                    pre_tail->next = headTail.head;
                else
                    //爲空，則虛擬頭結點指向新置鏈表頭結點
                    dummyHead->next = headTail.head;

                headTail.tail->next = next;

                //更新上一段鏈表的尾節點、下一段鏈表的頭結點和計數值count
                pre_tail = headTail.tail;
                newHead = next;
                count = 0;//別忘記計數值重置
            }
            
            head = next;
        }
        return dummyHead->next;//dummyHead大法好
    }

    //鏈表的頭和尾結構體
    struct HeadTail{
        ListNode *head;
        ListNode *tail;
    };

    //reverse函數返回兩個參數：倒置後的鏈表頭和尾
    HeadTail reverse(ListNode* head){
        //巧妙使用pre指針，初始值爲空
        ListNode *pre = nullptr;
        ListNode *cur = head;
        ListNode *next = head;
        while(cur){
            next = cur->next;
            //pre初始值爲空
            cur->next = pre;
            //更新pre值，很巧妙
            pre = cur;
            cur = next;
        }
        HeadTail headTail;
        headTail.head = pre;
        headTail.tail = head;

        return headTail;
    }
};