#leetcode刷题之路25- k个一组翻转链表

给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。

示例 :
给定这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5

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

思路：先把是不是从头开始区分一下，然后每一次翻转之前，都要判断数量够不够k

#include <iostream>
using namespace std;
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* createlist(int n)//生成链表
{
    if (n == ) return nullptr;
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    cin >> head->val;
    ListNode* pre = head;
    for (int i = ; i < n - ; i++)
    {
        ListNode* p = (ListNode*)malloc(sizeof(ListNode));
        cin >> p->val;
        pre->next = p;
        pre = pre->next;
    }
    pre->next = nullptr;
    return head;
}

ListNode* reverselist(ListNode* head, ListNode *p, int k)
{
    int tk = k;//暂时保存k的值
    if (head == p)//是头
    {
        ListNode* temp = head;//
        ListNode* endd = head;//
        ListNode* ttemp=nullptr;
        ListNode* pre = nullptr;//保存已反转的下一个
        ListNode* end = nullptr;//
        ListNode* t = head;//保存反转过的最后一个
        while (tk > )//说明从头节点开始有K个节点可供反转
        {
            if (temp != nullptr)
            {
                temp = temp->next;
                tk--;
            }
            else
                return head;
        }//while循环后temp指针指向链表的第K+1个节点
        //cout<<temp->val<<endl;
        //开始反转，让头指向空
        pre = head->next;
        head->next = nullptr;
        //cout<<temp->val<<endl;
        while (pre != temp)
        {
            //t = pre;
            end = pre->next;
            pre->next = head;
            head = pre;
            pre = end;
        }
        //cout << t->val << endl;
        endd->next = temp;//连接后面剩下的
        //带头的前k个处理完了，判断接下来的够不够k个
        tk = k;
        //temp = t;
        while (tk != )//是否可继续处理
        {
            if (temp != nullptr)
            {
                temp = temp->next;
                tk--;
            }
            else
                return head;
        }
        //cout << t->val <<t->next->val<< endl;
        //cout << head->val << head->next->val << endl;
        reverselist(head, t, k);//够的话就递归反转
    }
    else
    {
        ListNode* pre = p;//保存已经反转过的最后一个--------------------
        ListNode*cur = pre->next;//保存待反转的第一个
        ListNode* cur_next=cur->next ;//保存待反转的下一个
        ListNode* end = nullptr;//存放待反转的最后一个节点的下一个节点----------------------
        ListNode* thead=nullptr;//存放转后的头节点---------------
        ListNode* tcur = cur_next->next;//存放当前的cur_next的下一个节点,即下次要反转的那个------------------
        ListNode* temp = nullptr;//记录反转的链表尾
        ListNode* t = nullptr;//
        //-----------------------------先反转第一次

        cur_next->next = cur;
        cur->next = nullptr;
        temp = cur;
        thead = cur_next;
        tk = k-;
        while (tk > )
        {
            cur = tcur;
            tcur = tcur->next;
            cur->next = thead;
            thead = cur;
            tk--;
        }
        pre->next = thead;
        temp->next = tcur;
        t = temp->next;
        //带头的前k个处理完了，判断接下来的够不够k个
        tk = k;
        //temp = t;
        while (tk != )//是否可继续处理
        {
            if (t != nullptr)
            {
                t = t->next;
                tk--;
            }
            else
                return head;
        }
        reverselist(head, temp, k);//够的话就递归反转
    }
    return head;
}

ListNode* reverseKGroup(ListNode* head, int k) {
    if (head == nullptr || k ==  || k == ) return head;
    ListNode *temp = head;
    head = reverselist(head, head, k);
    return  head;
}

int main() {
    ListNode* head = createlist();
    ListNode*ans = reverseKGroup(head, );
    while (ans != nullptr)
    {
        cout << ans->val << endl;
        ans = ans->next;
    }
    return ;
}