手撸代码-链表中的节点每k个一组翻转-牛客

描述

将给出的链表中的节点每\ k k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是\ k k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
要求空间复杂度 \ O(1) O(1)

例如：

给定的链表是1→2→3→4→5
对于 k=2, 你应该返回 2→1→4→3→5
对于 k=3, 你应该返回 3→2→1→4→5

示例1

输入：
{1,2,3,4,5},2
返回值：
{2,1,4,3,5}

思路：

• 1，分组，每K个元素分为一组，将分组元素存入Map或者List
• 2，翻转，按照与存入顺序相反的取出元素，首尾相连成一个新的分组链表
• 3，将分组链表与原链表的前后两部分连接组成新的链表
  

关键点：

• 1，存储新链表的头部结点
• 2，将翻转后的链表与后半段链表连接
• 3，将翻转后的链表与前半段链表连接(保存前一次翻转的局部链表的尾结点)

public ListNode reverseKGroup (ListNode head, int k) {
        // write code here
        Map<Integer,ListNode> map = new HashMap<>();
        // 翻转后的新链表长度
        ListNode newListNode = null;

        // 用来协助记录整个链表的头部结点
        int len = 0;

        ListNode tmp = head;
        ListNode tail = null;
        while(tmp != null) {
            // 1，分组：每K个Node一组
            for(int i = 0; i < k && tmp != null; i++) {
                map.put(i,tmp);
                tmp = tmp.next;
                len++;
            }

            // 一组元素至少有K个才翻转
            if (map.size() == k) {
                // 2，翻转
                for(int i = k-1; i>=1; i--) {
                    map.get(i).next = map.get(i-1);
                }

                // 3，后连接：翻转后的链表的最后一个元素指向下一个元素
                map.get(0).next = tmp;

                if (len == k) {
                    // 链表的新的头部结点
                    newListNode = map.get(k-1);
                } else if(tail != null){
                    // 4，前连接：防止断链：上一组最后一个结点指向当前组的第一个结点
                    // 第一组不需要该操作
                    tail.next = map.get(k-1);
                }

                // 记住当前组的最后一个结点，下一组翻转时用来连接前后两组
                // tail在下一次翻转时使用，所以在当前翻转的最后步骤才赋值
                tail = map.get(0);
                map.clear();
            }
        }

        // 如果链表很短小于K，则没有翻转
        newListNode = newListNode != null ? newListNode : head;

        return newListNode;
    }