LeetCode25. K 个一组翻转链表

LeetCode25. K 个一组翻转链表

题目描述

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

思路分析

1. 先获取链表的长度len
2. 根据链表的长度len 除以 k 计算 每次反转k个元素 需要反转的次数 sum
3. 则循环 反转的次数sum次，及可实现k个节点一组反转
4. 每次将k个节点反转，可以使用栈结构，基于栈的先进后出原理
5. 将每次弹出的元素挂载到新链表后边
6. 最后还有将数量小于k的不用反转的节点挂载到新节点的后边
7. 详细思路见下

源码及分析

public ListNode reverseKGroup(ListNode head, int k) {
        //数据校验
        if (head == null || k < 1){
            throw new RuntimeException("数据错误~~");
        }
        if (k == 1){
            return head;
        }
        //获取链表的长度
        //因为head不能动，定义辅助变量cur
        ListNode cur = head;
        //定义变量保存链表的长度
        int len = 0;
        while (true){
            len++;
            cur = cur.next;
            if (cur == null){
                break;
            }
        }
        //定义一个虚拟头节点，让其下一个节点指向反转后链表的头节点
        ListNode newHead = new ListNode();
        //因为新链表头节点不能动，定义辅助变量
        ListNode cur2 = new ListNode();
        cur2 = newHead;
        //使用栈结构反转链表
        Stack<ListNode> stack = new Stack<>();
        //判断链表中共有多个个k个元素的组
        int sum = len / k;
        //共需要反转sum次，每次将k个元素反转
        for (int i = 0; i < sum; i++) {

            //入栈出栈实现反转的效果
            for (int j = 0; j < k; j++) {
                cur = head.next;
                head.next = null;
                stack.push(head);
                head = cur;
            }
            while (!stack.isEmpty()){
                cur2.next = stack.pop();
                cur2 = cur2.next;
            }

        }
        ListNode tmp = newHead;
        //找到新链表的最后一个节点
        while (true){
            if (tmp.next == null){
                break;
            }
            tmp = tmp.next;
        }
        //将剩下的元素个数小于k的节点加入到新链表后边
        tmp.next = cur;

        return newHead.next;
    }