Pattern: In-place Reversal of a LinkedList，反转链表

反转链表Ⅰ

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        ListNode *curr=head;//curr指向首元结点
        ListNode *prev=NULL;//prev指针为空
        ListNode *temp;
        while(curr!=NULL)
        {
            temp=curr->next;//temp指向curr所指向的下一结点
            curr->next=prev;//curr指向的下一个结点变为prev指向的结点
            prev=curr;//prev指向curr所指向的结点
            curr=temp;//curr指向temp所指向的结点
        }
        return prev;
    }
};

反转链表 II

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) 
    {
        //首先考虑特殊情况
        if(m==n)return head;
        //思路：创建一个头结点，先找到第m个结点，然后原地反转
        ListNode *newhead=new ListNode(0);//创建一个头结点
        newhead->next=head;
        ListNode *prev=newhead;
        for(int i=1;i!=m;++i)
            prev=prev->next;
        //循环结束，prev指向第m-1个结点
        ListNode *pl=prev;//记录第m-1个结点
        ListNode *pm=prev->next;//记录第m个结点
        ListNode *curr=prev->next;
        ListNode *temp;
        for(;m!=n+1;++m)//执行n-m+1次反转
        {
            temp=curr->next;
            curr->next=prev;
            prev=curr;
            curr=temp;
        }
        //循环结束，m-1到n之间的元素反转完成，
        //prev指向原来的第n个元素，curr指向第n+1个元素
        //连接
        pl->next=prev;
        pm->next=curr;
        return newhead->next;

        //思路2
        /*
        if(m==n)return head;
        ListNode *newhead=new ListNode(0);
        newhead->next=head;
        ListNode *prev=newhead;
        for(int i=1;i!=m;++i)
        {
            prev=prev->next;
        }
        ListNode *curr=prev->next;
        ListNode *temp;
        for(;m!=n;++m)
        {
            temp=curr->next;
            curr->next=temp->next;
            temp->next=prev->next;
            prev->next=temp;
        }
        return newhead->next;
        */
    }
};

（是时候祭出我画的丑图了XD

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) 
    {
        ListNode *newhead=new ListNode(0);//创建头节点
        newhead->next=head;
        int cnt=0;//统计链表长度
        while(head)
        {
            head=head->next;
            ++cnt;
        }
        ListNode *prev=newhead;
        ListNode *curr=prev->next;
        ListNode *temp;
        for(int i=0;i!=cnt/k;++i)//反转 cnt/k 组
        {
            for(int j=0;j!=k-1;++j)//注意每 k个结点进行翻转，事实上是翻转k-1次
            {
                temp=curr->next;
                curr->next=temp->next;
                temp->next=prev->next;
                prev->next=temp;
            }
            prev=curr;
            curr=curr->next;
        }
        return newhead->next;
    }
};