leetcode25---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

问题求解：

利用翻转链表的通用写法，本题就是不断循环翻转，直到最后一个group长度不足。

翻转链表算法思想：

1. 首先设置一个前置节点，将前置节点的next设置为头节点，以头节点为当前
节点，开始循环
2. 将当前节点的next赋给一个临时节点，然后将当前节点的next指向前置节
点，随后依次位移前置节点指针和当前节点指针：前置节点指针指向当前节点，当
前节点指针指向临时节点，这样就完成了一次循环
3. 当前置节点指针指向尾节点时，循环结束

利用翻转函数，只要对链表进行循环，当计数长度不等于k时，指针继续前进；当计数长度到达k时，将头尾节点作为参数传入翻转函数进行翻转，然后重新拼接到原链表中。直至到达链表末尾。

#include <iostream>
#include<stdlib.h>

using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(head==NULL || head->next==NULL || k==1) return head;

        ListNode* prehead=new ListNode(0);
        prehead->next=head;

        ListNode* begin=head;//group的起点
        ListNode* end=head;//group的终点

        ListNode* pregroup=prehead;//前一个group的最后一个指针,pregroup->next即为当前group开始位置
        ListNode* nextgroup=prehead;//下一个group的起点
        int num=1;//对group里的元素进行遍历
        while(end != NULL)
        {
            if(num == k)//3->2->1->6->5->4->...比如当前group为6->5->4
            {//达到了group长度
                nextgroup=end->next;//先找到下一个group的起点
                reverselist(begin, end);//对当前group进行逆序.  其自身begin和end已交换
                //逆序的group进行拼接 (1)(2)(3)的位置不能颠倒！！！！
                pregroup->next=end;//（1）当前group开始位置 6！！！！
                pregroup=begin;//（2）更新pregroup 4,作为下一group的前置节点！！！！
                begin->next=nextgroup;//（3）下一个group的前置指针为begin！！！！
                begin=nextgroup;
                end=nextgroup;
                num=1;
                continue;
            }
            end=end->next;
            num++;
        }
        return prehead->next;
    }
    //翻转链表的通用翻转函数
    void reverselist(ListNode* head, ListNode* tail)
    {//对给定的链表的一部分(group)进行逆序
        ListNode* prehead=new ListNode(0);//(1)首先设置一个前置节点
        prehead->next=head;//将前置节点的next设置为头节点
        ListNode* curnode=head;//以头节点为当前节点，开始循环
        while(prehead != tail)
        {
            ListNode* tmp=curnode->next;//(2)将当前节点的next赋给一个临时节点
            curnode->next=prehead;//然后将当前节点的next指向前置节点
            //随后依次位移前置节点指针和当前节点指针1),2)
            prehead=curnode;//1)前置节点指针指向当前节点
            curnode=tmp;//2)当前节点指针指向临时节点
        }
    }
    ListNode* CreateList(int a[], int n)
    {//头结点包含数据的情况
        ListNode *head, *p, *q;

        head = (ListNode*)malloc(sizeof(ListNode));
        head->next = NULL;

        p = head;
        p->val = a[0];
        //p->next = NULL;
        for(int i=1; i<n; i++)
        {
            q = (ListNode*)malloc(sizeof(ListNode));
            q->val = a[i];//数组元素给链表赋值！！！
            p->next = q;
            p = q;
        }
        p->next = NULL;//将最后一个结点的指针域清空
        return head;//返回这个链表的首地址
    }
};
int main()
{
    int a[]={1,2,3,4,5};
    //int a2[]={1,13,15};
    //int a3[]={2,4,8};
    //int a4[]={2,4,8};
    Solution s;
    ListNode *l1=s.CreateList(a, 5);
    //ListNode *l2=s.CreateList(a2, 3);
    //ListNode *l3=s.CreateList(a3, 3);
    ListNode *p1=l1;
    while(p1 != NULL)
    {
        cout<<p1->val<<" ";
        p1=p1->next;
    }
    cout<<endl;
    ListNode* head=s.reverseKGroup(l1, 2);
    ListNode *p=head;
    while(p != NULL)
    {
        cout<<p->val<<endl;
        p=p->next;
    }
    return 0;
}

执行结果：

1 2 3 4 5
2
1
4
3
5

Process returned 0 (0x0)   execution time : 0.129 s
Press any key to continue.