Leecode-25. K 个一组翻转链表(Leecode-24进阶，通俗易懂，详细)_给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。 k 是一个正整数,

题目描述(Leecode-24进阶)

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

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

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

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

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

说明：

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

1、因为题目要求是每k个节点一组翻转链表，那么我们可以从头开始，依次取出k个节点，然后依次翻转这k个节点，算法的核心思想就是简单的模拟。
2、从头开始依次判断能否取出k个节点，如果不能当前节点到链表尾部无需翻转，返回。每次翻转的时候，需要记录前一组的最后一个节点pre，因为只有这样，才能让翻转后的前一组链表链接到当前组的链表。
3、翻转时，需要注意的是，如果是第一组数据，还修改头指针。

实现代码（Java)

class Solution {
    public boolean judgeLegal(ListNode node,int k)//判断当前节点之后是否还存在k个节点，判断是否还需要进行翻转
    {
        int cnt=0;
        boolean ans=false;
        ListNode temp=node;
        while(temp!=null)
        {
            cnt++;
            if(cnt>=k)
            {
                ans=true;
                break;
            }
            temp=temp.next;
        }
        return ans;
    }
    public ListNode reverseKGroup(ListNode head, int k) {
        if(!judgeLegal(head,k))
        {
            return head;
        }
        ListNode [] tps=new ListNode[k];
        ListNode cur,pre;
        cur=head;
        pre=null;
        while(judgeLegal(cur,k))
        {
            for(int i=0;i<tps.length;i++)
            {
                tps[i]=cur;
                cur=cur.next;
            } //取出k个节点
            for(int i=tps.length-1;i>0;i--)
            {
                tps[i].next=tps[i-1];
            }//翻转链表
            if(pre==null)
            {
                head=tps[tps.length-1];
                tps[0].next=cur;
                pre=tps[0];
            } //如果为第一组数据，还需要修改头指针
            else
            {
                pre.next=tps[tps.length-1];
                tps[0].next=cur;
                pre=tps[0];
            }
        }
        return head;
    }
}
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
53
54

复杂度分析

算法中需要开辟一个大小为k的数组，空间复杂度为O(1)。
遍历整个链表的时间复杂度为O(N),每个链表节点会被记录放到一个数组中的的次数<=N，翻转操作时总共会经历的次数<=N，故整体算法的时间不超过3O(N),所以算法的时间复杂度是O(n)。

算法的可改进之处

1、可以新建一个指针hair，指向原链表的头指针，这样就可以不考虑，第一组节点翻转时需要修改头指针的问题，此时修改hair的指向，即可记录下链表各个节点的指向关系，这样的做法能减少代码量。
2、在判断当前节点之后是否还存在k个节点时，可以记录下这些节点，以避免在判断成功后再次对原链表记录所多耗费的时间。