LeetCode 25. K个一组翻转链表

LeetCode 25. K个一组翻转链表

1. 问题描述

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

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

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

进阶：

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

2. 思路

  双指针（pre指向上一个分组的最后一个节点，cur指向当前节点，要做的就是不停把cur的下一个节点翻转到当前分组的head处去）

算法流程：

1. 令头节点的前一个节点等于一个初始化的节点preHead，将preHead.Next = head
2. 令当前节点cur = head，当前节点的上一个节点pre = preHead
3. 遍历链表，得到长度length
4. 由于可以分为length / k个分组，当i < length / k时，执行循环
   
   4.1. 当j < k - 1时，执行循环
   
      4.1.1. 把当前节点的下一个节点next，保存
   
      4.1.2. 把当前节点的下一个节点更新为next.Next
   
      4.1.3. 把next翻转到当前分组的头部
   
      4.1.4. 把pre指向next
   
   4.2. pre 更新为cur，cur更新为cur.Next
5. 返回 preHead.Next

3. 代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseKGroup(head *ListNode, k int) *ListNode {
    preHead := &ListNode {
        Next : head,
    }

    pre := preHead
    cur := head

    var length int 
    for cur != nil {
        length++
        cur = cur.Next
    }
    cur = head

    for i := 0; i < length / k; i++ {
        for j := 0; j < k - 1; j++ {
            next := cur.Next
            cur.Next = next.Next
            next.Next = pre.Next
            pre.Next = next
        }
        pre = cur
        cur = cur.Next
    }
    return preHead.Next
}