K 个一组翻转链表

/**
 * 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) {
//记录头结点，因为头结点要指向第一组k个节点的尾节点
        ListNode start=head;
        ListNode end=getEndNode(start,k);
//如果第一组都不满足k个
        if(end==null){
            return head;
        }
//头结点指向第一组链表的尾节点
        head=end;
//反转
        reverse(start,end);
//记录第一组的开始节点，因为在以后的每一组反转之前都要先搜索到该组的起始节点和终止节点，即需要记录第一组节点的起始节点第二组开始时的起始节点需要重寻
        ListNode lastnode=start;
        while(lastnode!=null){
//新的起始节点变为上一次的end节点的下一个节点
            start=lastnode.next;
            end=getEndNode(start,k);
            if(end==null){
                return head;
            }
            reverse(start,end);
            lastnode.next=end;
            lastnode=start;
        }
        return head;
    }
//取以k为一组的链表的结尾
    public static ListNode getEndNode(ListNode start,int k){
        while(--k!=0&&start!=null){
            start=start.next;
        }
        return start;
    }
//反转子链表
    public static void reverse(ListNode start ,ListNode end){
        end=end.next;
        ListNode pre=null;
        ListNode cur=start;
        ListNode next=null;
        while(cur!=null){
            next=cur.next;
            cur.next=pre;
            pre=cur;
            cur=next;
        }
        start.next=end;
    }
}