(Java) LeetCode 25. Reverse Nodes in k-Group —— k个一组翻转链表

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

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

Note:

Only constant extra memory is allowed.
You may not alter the values in the list's nodes, only nodes itself may be changed.

本题是LeetCode 24. Swap Nodes in Pairs —— 两两交换链表中的节点的升级版。同时结合LeetCode 206. Reverse Linked List —— 反转链表就会有很多想法。

本题相当于将原链表的每个长度为k的子链表进行反转，之后再将逐段反转后的结果拼接起来。需要注意的是如果最后一段子链表不足k个，那就不需要反转。所以思路就很清晰了，先求出整个链表的长度，之后分割成k段，每段调用206题的程序反转子链表，之后将结果拼接即可。其实这样做每次都遍历了两次原链表，一次是分段，一次是反转分段后的链表（再加上计算长度，总共三次）。但运算速度竟然很高！再一次验证了LeetCode上的case可能都比较短吧…

当然此题还可以用递归来做，依然是利用缩小规模后的结果去计算更大规模的问题。详见代码注释。

解法一（Java）

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        //计算链表长度
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        ListNode preHead = new ListNode(0); //建立假节点存出结果
        preHead.next = head; 
        ListNode pre = preHead; 
        while (count >= k) {
            ListNode end = head; 
            for (int i = 1; i < k; i++) //计算出每k段子链表的尾节点
                end = end.next; 
            ListNode nextHead = end.next; //存储下一段子链表的开始
            end.next = null; //分割链表
            pre.next = reverseList(head); //反转子链表
            head.next = nextHead; //把反转后的子链表的尾节点与下一段链表头拼接
            pre = head; //移动指针到下一段链表头的前驱
            head = pre.next; //对下一个子链表进行相同操作
            count -= k;
        }
        return preHead.next;    
    }
    //见206题
    public ListNode reverseList(ListNode head) {
        ListNode first = head;
        ListNode reverseHead = null; 
        while (first != null) { 
            ListNode second = first.next; 
            first.next = reverseHead; 
            reverseHead = first; 
            first = second; 
        }
        return reverseHead;
    }
}

解法二（Java）

class Solution {
     public ListNode reverseKGroup(ListNode head, int k) {     
        ListNode cur = head;
        int count = 0;
        while (count < k && cur != null) {
            cur = cur.next;
            count++;
        }
        //分段递归
        if (count == k) {
            cur = reverseKGroup(cur, k); //cur存储反转k各节点之后的链表
            while (count > 0) { //反转本段链表，相当于以head为指针再一次遍历前k个节点，把从head开始的每一个节点放到cur前，然后head向后移动，cur向前移动，直到k次
                ListNode nextHead = head.next; 
                head.next = cur;
                cur = head;
                head = nextHead;
                count--;
            }
            head = cur; //把head重新放回到表头用以返回结果
        }
        return head;
     }
}

来源：oschina

链接：https://my.oschina.net/u/4396372/blog/3913163

标签