【数据结构】链表03：LeetCode 25. K 个一组翻转链表、LeetCode 24. 两两交换链表中的节点

注：本文全程采用头插法进行反转操作，采用一般反转的解法请看这篇题解。

LeetCode 25. K 个一组翻转链表

迭代解法

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode prev = dummy;
        while(prev != null){
            ListNode node = prev;
            int i = 0;
            for(; i<k; i++){
                node = node.next;
                if(node==null) break;
            }
            if(node == null) break;
            ListNode curr = prev.next;
            for(int j=0; j<i-1; j++){
                ListNode next = curr.next;
                curr.next = next.next;
                next.next = prev.next;
                prev.next = next;
            }
            prev = curr;
        }
        return dummy.next;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

拓展：“k个一组反转链表，不足k个也要反转”。
直接把中间那句if(node == null) break;去掉即可，i已经适配了“节点充足”和“不足k个”情况下需要反转的节点个数。
while循环的条件也可改为prev != null && prev.next != null。这样改的话，在最后会少做一次无用的循环。

递归解法

引入dummy节点，最后返回dummy.next即可，非常方便。如果不引入dummy节点的话，想要返回新的head就没那么容易了。
因为引入了dummy节点，所以递归函数要单独抽出来。

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null) return null;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        return reverseK(dummy, k);
    }
    ListNode reverseK(ListNode dummy, int k){
        if(dummy.next == null) return null;
        ListNode prev = dummy;
        ListNode node = prev;
        int i = 0;
        for(; i<k; i++){
            node = node.next;
            if(node==null) break;
        }
        if(node==null) return dummy.next;
        ListNode curr = prev.next;
        //需要反转i个节点，则需要“头插”i-1个节点
        for(int j=0; j<i-1; j++){
            ListNode next = curr.next;
            curr.next = next.next;
            next.next = prev.next;
            prev.next = next;
        }
        curr.next = reverseK(curr, k);
        return dummy.next;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

拓展：“k个一组反转链表，不足k个也要反转”。
直接把中间那句if(node==null) return dummy.next;去掉即可，i已经适配了“节点充足”和“不足k个”情况下需要反转的节点个数。

LeetCode 24. 两两交换链表中的节点

本题是上一题k=2的特殊情况。

迭代解法

将上一题迭代代码中k改成2，再做一下必要的修改，就可以通过。
但是，因为是k=2的情况，所以很多代码都可以精简。比如判断是否“节点充足”，直接用prev.next != null && prev.next.next != null就行了。再比如反转，只反转两个节点，就没必要再写一个for循环。

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode prev = dummy;
        while(prev.next != null && prev.next.next != null){
            ListNode node1 = prev.next;
            ListNode node2 = prev.next.next;
            node1.next = node2.next;
            node2.next = node1;
            prev.next = node2;
            prev = node1;
        }
        return dummy.next;
    }
}

递归解法

本题场景简单，新的head节点很好找，没必要引入dummy节点。

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode newHead = head.next;
        head.next = swapPairs(newHead.next);
        newHead.next = head;
        return newHead;
    }
}