LeetCode—reverse-nodes-in-k-group（k个一组反转链表）—java

题目描述：

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list:1->2->3->4->5

For k = 2, you should return:2->1->4->3->5

For k = 3, you should return:3->2->1->4->5

思路解析：

• 判断是否是空，或者只有一个节点，返回head就可以
• 然后需要新建一个dummy节点，作为头结点的前一个结点
• 然后计数从head开始满k就进行反转一次
• 注意需要协助一个函数功能是反转链表，传入的参数是需要反转的节点的前一个和后一个
• 这个函数返回的是反转链表中的尾结点，也就是下次反转的头结点的前一个结点
• 注意反转链表的方法，要提前记录头结点head

代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head ==null || head.next ==null)
            return head;
        int count =0;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;
        ListNode cur = head;
        while(cur!=null){
            ListNode next = cur.next;
            count++;
            if(count==k){
                pre = reverse(pre,next);
                count=0;
            }
            cur = next;
        }
        return dummy.next;
    }
    public ListNode reverse(ListNode pre,ListNode end){
        if(pre == null||pre.next ==null)
            return pre;
        ListNode head = pre.next;
        ListNode cur = pre.next.next;
        while(cur!=end){
            ListNode next = cur.next;
            cur.next = pre.next;
            pre.next = cur;
            cur = next;
        }
        head.next=end;//end其实是下一个要反转的头结点
        return head;
    }
}