LeetCode Java刷题笔记—25. K 个一组翻转链表

Posted 2022-05-10 刘Java

25. K 个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。k
是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k
的整数倍，那么请将最后剩余的节点保持原有顺序。你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换，且算法需要O(1)级别的空间复杂度。

困难难度。这道题实际上相当于92. 反转链表 II的进阶版本，如果理解了92题，那么这道题就比较好想到思路，或者理解别人的思路了，可以说该题时最容易考到的hard难度的链表题了。

我们首先计算节点的数量count，然后通过count/k就可以获取需要反转的轮次数，使用双重循环，外层循环表示第几轮次的反转，内层循环实现部分节点之间的反转（92. 反转链表 II）即可，比较好理解。

需要注意的是，内层循环从1开始，因为k个组的节点，需要翻转k-1次。

public ListNode reverseKGroup(ListNode head, int k) 
    //因为头节点是可变的，因此初始化哨兵节点来保存头节点
    ListNode dummy = new ListNode(0, head);
    //统计链表节点的数量
    int count = 0;
    while (head != null) 
        head = head.next;
        count++;
    
    //计算需要反转的轮次
    count /= k;
    //初始化pre节点，指向要反转的链表首节点的前驱节点
    ListNode pre = dummy;
    //head首先指向要反转的链表首节点
    head = pre.next;
    //外层循环表示count轮次的反转
    for (int i = 0; i < count; i++) 
        //内层循环对当前轮次范围内的部分链表节点进行反转，这一部分的思路同 Leetcode 92. 反转链表 II
        //注意，k个组的节点，需要翻转k-1次，因此这里的j从1开始
        for (int j = 1; j < k; j++) 
            //获取当前需要反转的节点的后继
            ListNode next = head.next;
            //当前节点的后继指向后继节点的后继
            head.next = next.next;
            //后继节点的后继指向前驱节点的后继
            next.next = pre.next;
            //前驱节点的后继指向当前节点的后继，完成反转
            pre.next = next;
        
        //每一轮的反转结束，我们需要调整pre和head的位置，pre节点永远指向要反转的节点的前驱节点，head首先指向要反转的链表首节点
        //上一轮反转完毕之后，head指向当前部分子链表的最后一个节点，也就是下一轮要反转的子链表头节点的前驱节点
        //因此让pre指向head，head指向head的后继
        pre = head;
        head = head.next;
    
    return dummy.next;

另一种方法是，一边计数，一边反转。

public ListNode reverseKGroup( ListNode head, int k )

   ListNode dummy = new ListNode( 0, head ), pre = dummy, tail = dummy;
   while( true )
      int count = 0;
      // 查看剩余部分长度是否大于等于 k
      while( tail != null && count != k )
         count++;
         tail = tail.next;
      
      if( tail == null )
         break;
      
      //反转链表

      //要反转的子链表的头节点，同时也将会作为下一个要反转的子链表的前驱节点
      head = pre.next;
      while( pre.next != tail )
         ListNode cur = pre.next;
         pre.next = cur.next;
         cur.next = tail.next;
         tail.next = cur;
      
      //指向下一个要反转的子链表的前驱节点
      pre = head;
      tail = head;
   
   return dummy.next;