2021-08-18 leetcode 25K 个一组翻转链表

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

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

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

进阶：

你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 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]

解题思路：
首先判断数组长度是否大于k，然后判断数组中有几个k，之后对长度为k的数据一一进行反转。之后再将接反转后的链表接入回原来的位置。
时间复杂度：O(n),n是链表长度
空间复杂度：O(1)

public class Solution {
    public  class ListNode {
      int val;
      ListNode next;
      ListNode() {}
      ListNode(int val) { this.val = val; }
      ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  }
  public ListNode reverseKGroup(ListNode head, int k){
    ListNode hair = new ListNode(0);
    hair.next = head;
    //head上的一个结点，将反转后的链表接回此结点
    ListNode pre = hair;
    while (head != null){
      ListNode tail = pre;
      //查看剩余部分的长度是否大于k
      for (int i = 0;i<k;++i){
        tail = tail.next;
        if (tail == null){
          return hair.next;
        }
      }
      ListNode nex =tail.next;
      ListNode[] reverse = myReverse(head,tail);
      head = reverse[0];
      tail = reverse[1];
      //将子链表重新接回原来的链表
      pre.next = head;
      tail.next = nex;
      pre = tail;
      head = tail.next;
    }
    return hair.next;
  }
  //反转链表
  public ListNode[] myReverse(ListNode head,ListNode tail){
      ListNode prev = tail.next;
      ListNode p = head;
      while (prev != tail){
        ListNode nex= p.next;
        p.next = prev;
        prev = p;
        p =nex;
      }
      return new ListNode[]{tail,head};
  }
}