25. K 个一组翻转链表(java)

题目描述

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

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

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

示例：

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

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

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

说明：

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

---

解法一：迭代分段翻转（空间O(1)）

1. 创建头结点，创建双指针pre、end
2. end走k个节点，
3. 创建新节点start、next，其中start-end为待翻转范围，pre为上次的终点，next为未翻转起点
4. 将待翻转范围进行翻转（反转链表迭代）
5. 更新节点

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        //创建头结点
        ListNode node = new ListNode(0);
        node.next =head;

        //创建双指针
        ListNode pre = node;
        ListNode end = node;

        while(end.next!=null){
            //扫描待反转范围
            for(int i=0;i<k&&end!=null;i++){
                end=end.next;
            }
            //范围不够k，直接退出
            if(end == null) break;
            ListNode start = pre.next;
            ListNode next = end.next;
            //断开链表 
            end.next =null;
            //翻转
            pre.next = reverse(pre);
            //连接链表
            start.next =next;
            //更新指针
            pre = start;
            end = start;
        }
    return node.next;
    }
    //反转链表
    public ListNode reverse(ListNode head){
        ListNode pre = null;
        //这里要用head  而不是head.next
        while(head!=null){
            ListNode temp =head.next;
            head.next = pre;
            pre = head;
            head = temp;
        }
        return pre;
    }
}

解法二：栈（空间O(k)）

把 k 个数压入栈中，然后弹出来的顺序就是翻转的

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        Deque<ListNode> stack = new ArrayDeque<ListNode>();
        ListNode dummy = new ListNode(0);
        ListNode p = dummy;
        while (true) {
            int count = 0;
            ListNode tmp = head;
            while (tmp != null && count < k) {
                stack.add(tmp);
                tmp = tmp.next;
                count++;
            }
            if (count != k) {
                p.next = head;
                break;
            }
            while (!stack.isEmpty()){
                p.next = stack.pollLast();
                p = p.next;
            }
            p.next = tmp;
            head = tmp;
        }
        return dummy.next;
    }
}

解法三：递归

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        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;
    }
}