LeetCode第25题

 reeclapple方法个人理解：

public class Solution {
        public ListNode reverseKGroup(ListNode head, int k) {
            if (head==null||head.next==null||k<2) return head;

            ListNode dummy = new ListNode(0);
            dummy.next = head;

            ListNode tail = dummy, prev = dummy,temp;
            int count;
            while(true){
                count =k;
                while(count>0&&tail!=null){
                    count--;
                    tail=tail.next;
                }
                if (tail==null) break;//Has reached the end


                head=prev.next;//for next cycle
            // prev-->temp-->...--->....--->tail-->....
            // Delete @temp and insert to the next position of @tail
            // prev-->...-->...-->tail-->head-->...
            // Assign @temp to the next node of @prev
            // prev-->temp-->...-->tail-->...-->...
            // Keep doing until @tail is the next node of @prev
                while(prev.next!=tail){
                    temp=prev.next;//Assign
                    prev.next=temp.next;//Delete

                    temp.next=tail.next;
                    tail.next=temp;//Insert

                }

                tail=head;
                prev=head;

            }
            return dummy.next;
        }
}

首先使用如下循环，得到每一个划分区块的尾节点。根据tail的值，可以判断是否余下k个节点，足够进行一次倒置。

while(count>0&&tail!=null){

    count--;

    tail=tail.next;

}

 

每次将prev后的节点、即区块的头部转移到tail后，当tail在prev后时，当前区块的倒置即完成

while(prev.next!=tail){

    temp=prev.next;//Assign

    prev.next=temp.next;//Delete

    temp.next=tail.next;

    tail.next=temp;//Insert

}

head = prev.next;

prev = head;

tail = head;

使用head来在当前区块划分完成后，得到下一区块的首部的前驱。

head = prev.next; head得到的是prev.next引用的副本，所以经过一轮倒置后，head.next被修改为下一区块的首部。

public ListNode reverseKGroup(ListNode head, int k) {
    ListNode curr = head;
    int count = 0;
    while (curr != null && count != k) { // find the k+1 node
        curr = curr.next;
        count++;
    }
    if (count == k) { // if k+1 node is found
        curr = reverseKGroup(curr, k); // reverse list with k+1 node as head
        // head - head-pointer to direct part,
        // curr - head-pointer to reversed part;
        while (count-- > 0) { // reverse current k-group:
            ListNode tmp = head.next; // tmp - next head in direct part
            head.next = curr; // preappending "direct" head to the reversed list
            curr = head; // move head of reversed part to a new node
            head = tmp; // move "direct" head to the next node in direct part
        }
        head = curr;
    }
    return head;
}

shpolsky 的方法采用递归，对于每个区块的倒置，每次将节点转移到curr前的方式。