Leetcode:NO.25 K 个一组翻转链表

题目

题目链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明：

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

解题记录

• 更据K的大小分组转换
• 记录每组头节点和尾节点
• 循环将头节点的值插入到尾节点的后面
• 遍历链表直到不满足K大小组出现，跳出

/**
 * @author ffzs
 * @describe K个一组翻转链表
 *
 * 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
 * k 是一个正整数，它的值小于或等于链表的长度。
 *
 * 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

 * 示例：
 *
 * 给你这个链表：1->2->3->4->5
 * 当 k = 2 时，应当返回: 2->1->4->3->5
 * 当 k = 3 时，应当返回: 3->2->1->4->5
 *
 * 说明：
 *
 * 你的算法只能使用常数的额外空间。
 * 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
 *
 * @date 2020/5/16
 */
public class reverseKGroup {

    static class ListNode {
        int val;
        ListNode next;
        ListNode(int x) { val = x; }

        @Override
        public String toString() {
            return "ListNode{" +
                    "val=" + val +
                    ", next=" + next +
                    '}';
        }
    }

    public static ListNode reverseKGroup (ListNode head, int k) {
        if (head==null) return null;
        ListNode res = new ListNode(-1);
        res.next = head;
        head = res;
        ListNode tail = res;
        while (true) {
            for (int i = 0; i < k && tail != null; i++) tail = tail.next;
            if (tail==null) break;
            ListNode pre = head.next;
            while (head.next != tail){
                ListNode tmp = head.next;
                head.next = tmp.next;
                tmp.next = tail.next;
                tail.next = tmp;
            }
            head = pre;
            tail = head;
        }
        return res.next;
    }


    public static void main(String[] args) {
        ListNode head = new ListNode(1);
        ListNode tmp = head;
        int[] lst = {2,3,4,5};
        for (int i :lst){
            tmp.next = new ListNode(i);
            tmp = tmp.next;
        }
        System.out.println(reverseKGroup(head, 2));
    }
}

进阶

使用递归求解

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public static ListNode reverseKGroup(ListNode head, int k) {
        if (head == null) return null;
        ListNode cur = head;
        int count = 0;
        while (cur != null && count != k) {
            cur = cur.next;
            count++;
        }
        if (count == k) {
            cur = reverseKGroup(cur, k);
            while (count != 0) {
                count--;
                ListNode tmp = head.next;
                head.next = cur;
                cur = head;
                head = tmp;
            }
            head = cur;
        }
        return head;
    }
}

来源：oschina

链接：https://my.oschina.net/u/4404863/blog/4281984