LeetCode 链表翻转(按K个一组) 详解

给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

• 你的算法只能使用常数的额外空间。
• 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
•          //涉及到链表指针的题目大多需要进行链的翻转，如下会用一个常用的
• 1、

  /**
   * 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* pre; 
          ListNode* p = head;  
          ListNode* q = head;  
          
          if(!p || k == 1) return p;  
          for(int i = 1; i < k; i ++){
              if(!q->next)    return head;
              q = q->next;
          }
          pre = p;  
          head = q;
          while(p->next != head){//翻转链表的核心
              q = p->next;      //1. 缓冲p后面的单链表
              p->next = p->next->next;   //2. 反转单链表
              q->next = pre;    //3.让pPre指针后移
              pre = q;       //4. 让pre指针后移
      
  
          }
          p->next =  reverseKGroup(head->next, k);
          head->next = pre;
   
          return head;        
      }
  };

  2、

• public ListNode reverseKGroup(ListNode head, int k) {
      if(head == null)
      {
          return null;
      }
      ListNode dummy = new ListNode(0);
      dummy.next = head;
      int count = 0;
      ListNode pre = dummy;
      ListNode cur = head;
      while(cur != null)
      {
          count ++;
          ListNode next = cur.next;
          if(count == k)
          {
              pre = reverse(pre, next);
              count = 0;   
          }
          cur = next;
      }
      return dummy.next;
  }
  private ListNode reverse(ListNode pre, ListNode end)
  {
      if(pre==null || pre.next==null)
          return pre;
      ListNode head = pre.next;
      ListNode cur = pre.next.next;
      while(cur!=end)
      {
          ListNode next = cur.next;//缓冲cur后面的链表
          cur.next = pre.next;//翻转单链表
          pre.next = cur;//让pre.next的指针后移，类似于后移head
          cur = next;//后移cur的指针
      }
      head.next = end;
      return head;
  }
  

  //直接翻转单链表
  
  ListNode *listReverse(ListNode *pHead)
  {
  	if(pHead == NULL)
  		return NULL;
  	ListNode *pCurrent ,*pPre,*pNext;
  	                              //一、指针的初始化阶段
  	pPre = pHead;
  	pCurrent = pPre->next ;
   
  	while(pCurrent)               //二、反转单链表的核心代码
  	{
  		pNext = pCurrent->next ;   //1. 缓冲pCurrent后面的单链表
  		pCurrent->next = pPre ;	   //2. 反转单链表
  		pPre = pCurrent;           //3.让pPre指针后移
  		pCurrent = pNext ;         //4. 让pCurrent指针后移
  	}
  					   //三、处理并返回头指针
  	pHead->next = NULL;                //把原头结点的next域变成空指针
  	pHead = pPre ;		           //把头结点指向最后一个结点产生新的头结点，也就是把原单链表的尾结点变成头结点
   
  	return pHead;
  }