K个一组翻转链表

题目

  给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。k是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。在翻转的过程有如下两点要求：只使用常数额外空间的算法来解决此问题和必须实际进行节点交换。

  示例 1:

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

  示例 2:

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

  示例 3:

输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]

翻转

算法思路

  这是一个典型的链表节点交换问题，算是LeetCode 206题反转链表的一个扩展。那么我们想要针对k对链表进行分组翻转，首先我们需要把链表中的节点按照K个一组分组，为了要实现每K个节点一组的效果，所以我们在每次遍历中将head向前走k步，并标记出当前分组的tail尾节点。这样一来从head到tail之间的节点就是我们本次需要翻转的节点。
  该题的翻转比LeetCode 24题两两交换要复杂一些，因为这里的需要翻转的节点数是未知的，所以我们需要单独对head到tail之间的节点进行遍历，每次将遍历得到的节点连接到上一次遍历的进行翻转的节点上。为了满足以上效果，我们需要定义一个reverseTail来作为每次遍历需要翻转节点，并在每次遍历翻转后进行更新；除此之外还需要定义一个reverseHead用来标记翻转节点需要连接的后继节点，也就是上一次遍历翻转的那个节点。
  最后我们还需要将每个翻转后的分组连接起来，所以需要定义一个prev节点用于连接各个分组，prev在每次遍历中更新其值，每次都将其更新为前一个分组的尾节点，这样一来就可以在下一次遍历时连接下一个翻转后的分组。

编码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution{
  public ListNode reverseKGroup(ListNode head, int k) {
    if(head == null || k <= 0){
      return head;
    }
    // 定义一个统领所有节点的辅助节点
    ListNode leader = new ListNode(-1);
    leader.next = head;
    // 定义一个前驱节点，用于连接各分组
    ListNode prev = leader;
    while(head != null){
      // 定义一个尾节点，每次向前走k步
      ListNode tail = prev;
      for(int i=0; i<k; i++){
        tail = tail.next;
        if(tail == null){
          return leader.next;
        }
      }
      
      // 每次遍历进行翻转时，尾节点要连接的后继节点
      ListNode reverseHead = tail.next;
      // 每次遍历进行翻转时，当前需要处理的尾节点
      ListNode reverseTail = head;
      while(reverseHead != tail){
        // 翻转节点
        ListNode nextTail = reverseTail.next;
        reverseTail.next = reverseHead;
        reverseHead = reverseTail;
        reverseTail = nextTail;
      }
      
      // 通过定义的前驱节点，连接各个分组
      prev.next = reverseHead;
      // 指定下一次遍历的前驱节点
      prev = head;
      // 指定下一次遍历的首节点
      head = reverseTail;
    }
    return leader.next;
  } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

复杂度分析

  时间复杂度为O(n)，其中n是链表的长度，因为我们要对链表进行一次遍历，每次遍历又会根据k值向前走k个节点并进行翻转，所以综合复杂度就为O(n)。因为没有开辟任何额外的内存空间，所以空间复杂度为O(1)。