小红书：每K个一组反转链表（Python语言实现）

题目描述

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

说明：
1.你需要自行定义链表结构，将输入的数据保存到你的链表中；
2.你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换；
3.你的算法只能使用常数的额外空间。

• 输入描述

第一行输入是链表的值
第二行输入是K的值，K是大于或等于1的整数

输入形式为：
1 2 3 4 5
2

• 输出描述

当k = 2时，应当输出: 2 1 4 3 5

当k = 3时，应当输出: 3 2 1 4 5

当k=6时，应当输出： 1 2 3 4 5

• 示例

输入：
1 2 3 4 5
2

输出：
2 1 4 3 5

双指针反转链表

首先设立头节点可以避免第一次旋转时的特殊情况考虑，在旋转过程中传入两个参数第一个节点与最后一个节点的下一个给局部旋转函数，返回值分别为当前要旋转的链表的第一个节点与最后一个节点，这样方便将当前部分与前一个部分断开的头尾相连。

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


def value_to_list(seq):
    head = p = ListNode(float('inf'))
    for su in seq:
        q = ListNode(su)
        p.next = q
        p = q
    return head


def list_to_value(head):
    res = []
    p = head
    while p:
        res.append(str(p.val))
        p = p.next
    return ' '.join(res[1:])


def rotate_k_node_of_list(head, k):
    if k == 1:
        return head
    left = head
    while True:
        front, rear = left.next, left.next
        count = 0
        while rear and count < k:
            rear = rear.next
            count += 1
        if count == k:
            one, two = rotate(front, rear)
            left.next = one
            left = two
        else:
            break
    return head


def rotate(front, rear):
    p, q = front, front
    while q.next and q.next != rear:
        cur = q.next
        q.next = cur.next
        cur.next = p
        p = cur
    return p, q


if __name__ == '__main__':
    seq = list(map(int, input().strip().split()))
    k = int(input().strip())
    head = value_to_list(seq)
    node = rotate_k_node_of_list(head, k)
    res = list_to_value(node)
    print(res)

（最近更新：2019年09月02日）