K个一组翻转链表

LEETCODE 25

链表相关题目看起来思路容易找，但是细节和边界条件较多，很容易出错。
就这道题来说，k将链表分为若干个组，我们要考虑的问题有：

1. 组内的反转，可以参考前面的链表反转；
2. 组之间的连接；
3. 如过最后一个组数目不足k的处理；
   大多数链表和二叉树相关的题目可以优先考虑递归的方法来做，虽然本题要求常数的空间复杂度，但还是可以试试。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
     if(head==0||k==1)return head;
     auto p2=head,cur=head;
     int cnt=1;
     while(p2)
     {
         p2=p2->next;
         if(++cnt>=k)break;
     }
     if(p2==0&&cnt<=k)return head;
    ListNode *pre=0;
    cnt=1;
    while(cur)
    {
        auto temp=cur->next;
        cur->next=pre;
        pre=cur;
        cur=temp;
        if(++cnt==k+1)break;
    }
     if(cur)
       head->next=reverseKGroup(cur, k);
      else 
          head->next=0;
     return pre;
    }
};

用递归我们要考虑几个问题：
1.如何自上而下的将问题规模缩小；就本题而言，我们翻转完k个节点后剩下的节点就组成了一个子问题；
2.递归函数返回什么；这道题很明显返回的是翻转后的头节点；
3.最小的子问题是什么，即递归结束的条件。这道题就是当节点数目不足k的时候；

也可以用迭代的方式去实现，基本思路也是一样的，各种细节处理要复杂一些，但是更加复杂题目O(1)空间复杂度的要求；

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
      ListNode* res=new ListNode(0);
      res->next=head;
      auto pre=res,cur=pre;
      while(true)
      {
          int cnt=0;
          while(cur&&cnt!=k)
          {
              cur=cur->next;
              ++cnt;
          }
          if(cur==0)break;
          auto head1=pre->next,p=pre->next;
          while(head1!=cur)
          {
              auto temp=head1->next;
              pre->next=head1->next;
              head1->next=cur->next;
              cur->next=head1;
              head1=temp;         
          }
          pre=p;
          cur=p;
      }
        return res->next;
    }
};

对于链表的问题有时候增加一个哨兵节点对于解题有很大的帮助，使得代码写的更加流畅清晰；