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

 

 

SOLUTION 1

用递归实现，逐层进行反转。遇到最后一个如果个数不为k，再反转一次即可。

/*
    SOLUTION 2: A better rec version.
    */
    public ListNode reverseKGroup2(ListNode head, int k) {
        if (head == null) {
            return null;
        }        
        
        return rec2(head, k);
    }
    
    public ListNode rec2(ListNode head, int k) {
        if (head == null) {
            return null;
        }
        
        ListNode dummy = new ListNode(0);
        
        ListNode cur = head;
        int cnt = 0;
        while (cur != null) {
            ListNode tmp = cur.next;
            cur.next = dummy.next;
            dummy.next = cur;
            
            cur = tmp;
            
            cnt++;
            
            // reverse a k group.
            if (cnt == k) {
                // BUG 1: 
                head.next = rec2(tmp, k);
                return dummy.next;
            }
        }
        
        // we don't have k nodes.
        if (cnt != k) {
            cur = dummy.next;
            dummy.next = null;
            
            // reverse again.
            while (cur != null) {
                ListNode tmp = cur.next;
                cur.next = dummy.next;
                dummy.next = cur;
                
                cur = tmp;
            }
        }
        
        return dummy.next;
    }

 

SOLUTION 2

另一个思路的递归：

先查看有没有k个node，如果有，切开2个链表，反转当前链表，并且使用递归处理下一个section，最后再把2者连接起来即可。

public ListNode reverseKGroup1(ListNode head, int k) {
        if (head == null) {
            return null;
        }        
        
        return rec(head, k);
    }
    
    // Solution 1: Recursion.
    public ListNode rec(ListNode head, int k) {
        // Reverse k and link to the next section.
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        
        // find the tail node of the section. If not find, just return.
        int cnt = k;
        ListNode tail = dummy;
        while (cnt > 0 && tail != null) {
            cnt--;
            tail = tail.next;
        }
        
        // We don't have k nodes to revers.
        // bug 1: we should judge that if tail == null to avoid the overflow.
        if (tail == null) {
            return head;
        }
        
        // cut the 2 list.
        ListNode next = tail.next;
        tail.next = null;
        
        // reverse the first list.
        ListNode newHead = reverse(head);
        
        // reverse the next section.
        next = rec(next, k);
        
        // link the 2 sections.
        head.next = next;
        
        return newHead;
    }
    
    public ListNode reverse(ListNode head) {
        ListNode dummy = new ListNode(0);
        while (head != null) {
            ListNode tmp = head.next;
            head.next = dummy.next;
            dummy.next = head;
            
            head = tmp;
        }
        
        return dummy.next;
    }

 

SOLUTION 3

使用一个专用的反转函数来进行反转，从头到尾遍历，遍历到K的时候，使用Pre-Next指针的方式进行反转。这个方法比递归更棒。

要特别注意的是：

reverseSection 函数中，while 循环的终止条件不是cur != null,而是cur != next。这一点要特别注意，否则很容易造成死循环！

// BUG: Severe. if we use cur != null here, we will cause very serious loop error.
while (cur != next) {
   ...
}

/*
    SOLUTION 3: A Iteration version.
    */
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null) {
            return null;
        }        
        
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        
        ListNode pre = dummy;
        ListNode cur = pre.next;
        
        int cnt = 0;
        while (cur != null) {
            cnt++;
            cur = cur.next;
            
            if (cnt == k) {
                cnt = 0;
                pre = reverseSection(pre, cur);
                cur = pre.next;
            }
        }
        
        return dummy.next;
    }
    
    
    /**
     * Reverse a link list between pre and next exclusively
     * an example:
     * a linked list:
     * 0->1->2->3->4->5->6
     * |           |   
     * pre        next
     * after call pre = reverse(pre, next)
     * 
     * 0->3->2->1->4->5->6
     *          |  |
     *          pre next
     * @param pre 
     * @param next
     * @return the reversed list's last node, which is the precedence of parameter next
     */
    private static ListNode reverseSection(ListNode pre, ListNode next){
        ListNode cur = pre.next;
        
        // record the new tail.
        ListNode tail = cur;
        
        // BUG: Severe. if we use cur != null here, we will cause very serious loop error.
        while (cur != next) {
            ListNode tmp = cur.next;
            cur.next = pre.next;
            pre.next = cur;
            cur = tmp;
        }
        
        tail.next = next;
        return tail;
    }

 

GITHUB:

1. 主页君的GitHub代码

2. 2014.1227 Redo:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/list/ReverseKGroup_1227_2014.java

ref: http://www.cnblogs.com/lichen782/p/leetcode_Reverse_Nodes_in_kGroup.html