[leetcode]Reverse Nodes in k-Group

Reverse Nodes in k-Group

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

算法思路：

1. 判断字符串长length < k 则直接返回

2. 将前k个节点截取下来，reverse，并找到reverse后的尾节点

3. 递归，将后来生成的结果都插入到队列后面

public class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || k <= 1) return head;
        ListNode tail = head;
        int length = 1;
        while(tail.next != null){
            length++;
            tail = tail.next;
            if(length == k) break;
        }
        if(length < k) return head;//judge if the list need to process
        ListNode left = tail.next;
        tail.next = null;
        ListNode result = reverse(head);
        tail = result;
        while(tail.next != null){//find the tail node of the reversed list
            tail = tail.next;
        }
        tail.next = reverseKGroup(left, k);
        return result;
    }
    private ListNode reverse(ListNode head){
        ListNode pre = head;
        ListNode thus = head.next;
        ListNode post = thus.next;
        pre.next = null;
        while(thus != null){
            thus.next = pre;
            pre = thus;
            thus = post;
            if(post != null)post = post.next;
        }
        return pre;
    }
}

 

第二遍记录：

看了上一遍的代码就没兴趣看了，采用头插法，并记录剩余节点个数，当剩余节点数 < k时，就不需要处理了。

 

public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || head.next == null || k <= 0) return head;
        int length = 0;
        ListNode hhead = new ListNode(0);
        hhead.next = head;
        ListNode tail = head, p = hhead;
        for(; tail != null; tail = tail.next, length++);
        while(length >= k){
            ListNode newTail = p.next;
            for(int i = 0; i < k - 1; i++){
                ListNode pointer = newTail.next;
                newTail.next = pointer.next;
                pointer.next = p.next;
                p.next = pointer;
            }
            p = newTail;
            length -= k;
        }
        return hhead.next;
    }
}

 

FYI