[链表]LeetCode 25 K组一个翻转链表

LeetCode 25 k组一个翻转链表

---

TITLE

示例 1：

输入：head = [1,2,3,4,5], k = 2

输出：[2,1,4,3,5]

示例 2：

输入：head = [1,2,3,4,5], k = 3

输出：[3,2,1,4,5]

示例 3：

输入：head = [1,2,3,4,5], k = 1

输出：[1,2,3,4,5]

示例 4：

输入：head = [1], k = 1

输出：[1]

（PS:还是加上title吧不然太难受了)

---

前言：LeetCode难度hard，本体解决为链表分组处理的思想，分组进行链表翻转之后在进行链接，不知道为什么写了两天，秀逗了.

---

题目分析

首先实现翻转链表的方法此题用‘递归-回溯’的方法比较简单，需要注意的一点是在‘递归-回溯’结束时返回的节点为之前的头节点，所以注意预处理局部链表的头尾指针，并且在一组结束的时候对下一组的头尾指针进行预处理。

1. 分组链表
2. 初始化头尾指针
3. 指针移动记位，当长度为一组进行反转
4. 链表之间的链接处理
5. 反转后初始化头尾指针
   
   总结。2345循环执行

---

执行耗时:0 ms,击败了100.00% 的Java用户

内存消耗:41.4 MB,击败了5.10% 的Java用户

链表反转

private ListNode swapGroup(ListNode head,int k){
        if(k == 1){
            return head;
        }
        ListNode next = swapGroup(head.next,k - 1);
        head.next = null;
        next.next = head;
        return head;
    }

分组处理链表

public ListNode reverseKGroup(ListNode head, int k) {
        int mark = k;
        ListNode header = new ListNode();//头节点指针作为答案返回
        ListNode pointer_fast = new ListNode();//移动指针
        ListNode pointer_slow = new ListNode();//头指针
        //指针初始化
        header.next = head;
        pointer_slow = header;
        pointer_fast = header;
        //头尾链接处理的中间指针
        ListNode pre = new ListNode();
        int size = 0;
        while(pointer_fast!=null){
            if(size == k){
                //交换之前预备处理 分组之间的头尾链接预处理数据
                pre = pointer_fast.next;
                //接收原来分组链表的头节点现在的尾节点
                ListNode callBack = swapGroup(pointer_slow.next,k);
                //头尾链接处理
                callBack.next = pre;
                pointer_slow.next = pointer_fast;
                //初始化指针处理
                pointer_fast = callBack;
                pointer_slow = callBack;
                size = 0;
            }
            if(pointer_fast==null)break;
            pointer_fast = pointer_fast.next;
            size++;
        }
        return header.next;
    }