LeetCode25. K 个一组翻转链表

题目

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。链接

思路

递归，每次翻转k个节点，当不够k个节点时直接返回head

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode tail=head;
        int step=0;
        while(step<k&&tail!=null){
            tail=tail.next;
            step++;
        }
        if(step<k){
            return head;
        }
        ListNode dummy=null;
        ListNode first=head;
        while(first!=tail){
            ListNode t=first.next;
            first.next=dummy;
            dummy=first;
            first=t;
        }
        //翻转后，head变成末尾，与下一层的dummy头相连
        head.next=reverseKGroup(first,k);
        return dummy;
    }
}

迭代

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode pre=dummy;
        while(head!=null){
            ListNode tail=pre;
            for(int i=0;i<k;++i){
                tail=tail.next;
                //节点不够k个，直接返回dummy	
                if(tail==null){
                    return dummy.next;
                }
            }
            //保存下一段的头
            ListNode tailNex=tail.next;
            ListNode[]ret=reverse(head,tail);
            //上一段头连接
            pre.next=ret[0];
            //赋值翻转后的尾
            tail=ret[1];
            //连接下一段的头
            tail.next=tailNex;
            //更新pre
            pre=tail;
            //下一段翻转的head
            head=tail.next;
        }
        return dummy.next;
    }

    private ListNode[]reverse(ListNode head,ListNode tail){
        ListNode pre=tail.next;
        ListNode cur=head;
        while(pre!=tail){
            ListNode nex=cur.next;
            cur.next=pre;
            pre=cur;
            cur=nex;
        }
        //翻转后头尾交换
        return new ListNode[]{tail,head};
    }
}