LeetCode：Reverse Nodes in k-Group - 分組翻轉鏈表

一、題目名稱

Reverse Nodes in k-Group（分組翻轉鏈表）

二、題目地址

https://leetcode.com/problems/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.

中文：

給出一個鏈表，以k個元素爲一組，對各組內元素進行翻轉。忽略最後不夠k的元素的部分。能夠只對節點中的值進行交換，空間複雜度須控制在O(1)。

舉例：

給出鏈表：1->2->3->4->5

當 k = 2 時，翻轉後的鏈表爲：2->1->4->3->5

當 k = 3 時，翻轉後的鏈表爲：3->2->1->4->5

四、解題方法

對這個問題，在給出鏈表的首節點nodeCurr和每組節點數k後，能夠分解成三個子問題：

1. 判斷鏈表剩餘部分是否還須要翻轉（剩餘部分不夠k個元素就不翻轉）

2. 翻轉鏈表中包括首節點在內的前k個元素

3. 定位到下一組的首節點
   

循環執行這三個函數，直到執行第一步時斷定爲不須要翻轉爲止

一個實現此算法的Java代碼以下：

/**
 * 功能說明：LeetCode 25 - Reverse Nodes in k-Group
 * 開發人員：Tsybius2014
 * 開發時間：2015年8月10日
 */
public class Solution {
    
    /**
     * 以k個結點一組來翻轉鏈表
     * @param head
     * @param k
     * @return
     */
    public ListNode reverseKGroup(ListNode head, int k) {
        
        ListNode nodeCurr = head;
        while (needToReverse(nodeCurr, k)) {
            reverseOneKGroup(nodeCurr, k);
            nodeCurr = nextKGroup(nodeCurr, k);
        }
        
        return head;
    }
    
    /**
     * 判斷剩餘長度是否有必要進行翻轉
     * @param listNode
     * @param k
     * @return
     */
    public boolean needToReverse(ListNode node, int k) {
        if (node == null) {
            return false;
        }
        while (--k != 0) {
            node = node.next;
            if (node == null) {
                return false;
            }
        }
        return true;
    }

    /**
     * 翻轉一組長度爲k的鏈
     * @param node
     * @param k
     */
    public void reverseOneKGroup(ListNode node, int k) {
        ListNode nodeToReverse; //要互換值的對稱位置結點
        int distance = k - 1; //當前結點距離要翻轉的對稱位置結點的長度
        int temp;
        for (int i = 0; i < k / 2; i++) {
            if (i > 0) {
                node = node.next;
                distance -= 2;
            }
            if (node == null) {
                return;
            }
            nodeToReverse = node;
            for (int j = 0; j < distance; j++) {
                nodeToReverse = nodeToReverse.next;
                if (nodeToReverse == null) {
                    return;
                }
            }
            temp = node.val;
            node.val = nodeToReverse.val;
            nodeToReverse.val = temp;
        }
    }
    
    /**
     * 下一組結點
     * @param listNode
     * @return
     */
    public ListNode nextKGroup(ListNode node, int k) {
        if (node == null) {
            return null;
        }
        while (k-- != 0) {
            node = node.next;
            if (node == null) {
                return null;
            }
        }
        return node;
    }
}

END