螺旋矩阵 II：从理论到实践的五种算法解析

作者介绍：10年大厂数据\经营分析经验，现任大厂数据部门负责人。
会一些的技术：数据分析、算法、SQL、大数据相关、python
欢迎加入社区：码上找工作
作者专栏每日更新：
LeetCode解锁1000题: 打怪升级之旅
python数据分析可视化：企业实战案例
备注说明：方便大家阅读，统一使用python，带必要注释，公众号 数据分析螺丝钉 一起打怪升级

题目描述

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

输入格式

• head：链表的头节点。
• k：一个整数，表示旋转的位置数。

输出格式

• 返回旋转后的链表的头节点。

示例

示例 1

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

示例 2

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

---

方法一：闭合为环

解题步骤

1. 链表长度：首先遍历整个链表得到链表长度 n 和最后一个节点。
2. 闭合成环：将链表的尾节点连接到头节点，形成环。
3. 计算新头位置：根据 k % n 计算新的头节点的位置。
4. 重置头节点：找到新的头节点和尾节点，断开环。

完整的规范代码

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

def rotateRight(head, k):
    """
    使用闭合环的方法进行链表旋转
    :param head: ListNode, 链表的头节点
    :param k: int, 旋转的位置数
    :return: ListNode, 旋转后的链表头节点
    """
    if not head or not head.next or k == 0:
        return head
    
    # 计算链表长度并形成环
    lastElement = head
    length = 1
    while lastElement.next:
        lastElement = lastElement.next
        length += 1
    lastElement.next = head
    
    # 找到新的尾部：（长度 - k % 长度 - 1）的位置
    k = k % length
    steps_to_new_tail = length - k
    new_tail = head
    for i in range(steps_to_new_tail - 1):
        new_tail = new_tail.next
    
    new_head = new_tail.next
    
    # 断开环
    new_tail.next = None
    
    return new_head

# 示例代码用于创建链表和打印链表
def create_list(lst):
    head = current = ListNode(lst[0])
    for number in lst[1:]:
        current.next = ListNode(number)
        current = current.next
    return head

def print_list(node):
    while node:
        print(node.val, end=" -> ")
        node = node.next
    print("NULL")

# 示例调用
lst = create_list([1, 2, 3, 4, 5])
rotated_lst = rotateRight(lst, 2)
print_list(rotated_lst)  # 输出: 4 -> 5 -> 1 -> 2 -> 3 -> NULL

算法分析

• 时间复杂度：(O(n))，主要时间开销来自于链表遍历和旋转计算。
• 空间复杂度：(O(1))，除了给定的链表结构，只使用常数额外空间。

方法二：数组模拟

解题步骤

1. 转换为数组：遍历链表，存储每个节点的值到数组中。
2. 数组旋转：对数组进行旋转操作。
3. 重建链表：根据旋转后的数组重建链表。

完整的规范代码

def rotateRight(head, k):
    """
    使用数组模拟链表旋转
    :param head: ListNode, 链表的头节点
    :param k: int, 旋转的位置数
    :return: ListNode, 旋转后的链表头节点
    """
    if not head or not head.next or k == 0:
        return head
    
    # 转换链表到数组
    nodes = []
    current = head
    while current:
        nodes.append(current.val)
        current = current.next
    
    # 数组旋转
    k = k % len(nodes)
    nodes = nodes[-k:] + nodes[:-k]
    
    # 重建链表
    new_head = current = ListNode(nodes[0])
    for val in nodes[1:]:
        current.next = ListNode(val)
        current = current.next
    
    return new_head

# 示例调用
lst = create_list([1, 2, 3, 4, 5])
rotated_lst = rotateRight(lst, 2)
print_list(rotated_lst)  # 输出: 4 -> 5 -> 1 -> 2 -> 3 -> NULL

算法分析

• 时间复杂度：(O(n))，包括链表到数组的转换和数组的旋转。
• 空间复杂度：(O(n))，需要额外空间来存储链表元素的数组。

方法三：直接旋转

解题步骤

1. 链表遍历：计算链表长度并连接成环。
2. 计算新尾部：根据旋转次数确定新的尾部位置。
3. 重建链表：在新的尾部断开环，形成新的链表。

完整的规范代码

def rotateRight(head, k):
    """
    直接通过链表旋转实现
    :param head: ListNode, 链表的头节点
    :param k: int, 旋转的位置数
    :return: ListNode, 旋转后的链表头节点
    """
    if not head or not head.next or k == 0:
        return head
    
    # 计算长度并形成环
    old_tail = head
    length = 1
    while old_tail.next:
        old_tail = old_tail.next
        length += 1
    old_tail.next = head
    
    # 计算新尾部位置
    k = k % length
    new_tail = head
    for i in range(length - k - 1):
        new_tail = new_tail.next
    
    new_head = new_tail.next
    new_tail.next = None
    
    return new_head

# 示例调用
lst = create_list([1, 2, 3, 4, 5])
rotated_lst = rotateRight(lst, 2)
print_list(rotated_lst)  # 输出: 4 -> 5 -> 1 -> 2 -> 3 -> NULL

算法分析

• 时间复杂度：(O(n))，需要遍历链表两次。
• 空间复杂度：(O(1))，仅使用常数额外空间。

方法四：改进的数组模拟

解题步骤

1. 转换为数组：将链表节点转换为数组，方便随机访问。
2. 数组旋转：对数组进行旋转操作。
3. 重建链表：根据旋转后的数组重建链表。

完整的规范代码

def rotateRight(head, k):
    """
    使用改进的数组模拟方法旋转链表
    :param head: ListNode, 链表的头节点
    :param k: int, 旋转的位置数
    :return: ListNode, 旋转后的链表头节点
    """
    if not head:
        return None
    
    # 转换链表到数组
    nodes = []
    while head:
        nodes.append(head)
        head = head.next
    
    k = k % len(nodes)
    nodes = nodes[-k:] + nodes[:-k]
    
    # 重建链表
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    nodes[-1].next = None
    
    return nodes[0]

# 示例调用
lst = create_list([1, 2, 3, 4, 5])
rotated_lst = rotateRight(lst, 2)
print_list(rotated_lst)  # 输出: 4 -> 5 -> 1 -> 2 -> 3 -> NULL

算法分析

• 时间复杂度：(O(n))，链表到数组的转换和数组旋转各需要 (O(n))。
• 空间复杂度：(O(n))，需要额外空间来存储节点指针的数组。

方法五：反向索引旋转

解题步骤

1. 链表遍历：一次遍历计算链表长度并形成尾部连接。
2. 反向计算头部：使用长度减去 (k % \text{长度}) 计算新头部和尾部位置。
3. 断开连接：在新尾部断开链表，形成新的链表结构。

完整的规范代码

def rotateRight(head, k):
    """
    使用反向索引旋转链表
    :param head: ListNode, 链表的头节点
    :param k: int, 旋转的位置数
    :return: ListNode, 旋转后的链表头节点
    """
    if not head or not head.next or k == 0:
        return head
    
    # 完成一次完整遍历以确定长度并形成环
    last = head
    length = 1
    while last.next:
        last = last.next
        length += 1
    last.next = head
    
    # 确定新的头部和尾部
    k = k % length
    if k:
        for _ in range(length - k):
            last = last.next
    head = last.next
    last.next = None
    
    return head

# 示例调用
lst = create_list([1, 2, 3, 4, 5])
rotated_lst = rotateRight(lst, 2)
print_list(rotated_lst)  # 输出: 4 -> 5 -> 1 -> 2 -> 3 -> NULL

算法分析

• 时间复杂度：(O(n))，可能需要遍历链表两次（计算长度和调整位置）。
• 空间复杂度：(O(1))，不需要额外的存储空间，除了输入的链表。

不同算法的优劣势对比

特征	方法一: 闭环	方法二: 数组模拟	方法三: 直接旋转	方法四: 改进数组模拟	方法五: 反向索引旋转
时间复杂度	(O(n))	(O(n))	(O(n))	(O(n))	(O(n))
空间复杂度	(O(1))	(O(n))	(O(1))	(O(n))	(O(1))
优势	直观简单，实现快速	方便理解和实现，便于调试	减少了中间转换步骤，提高效率	易于理解和操作，灵活处理	计算头尾连接，避免额外空间，快速
劣势	需要特别处理新的头尾	需要额外空间存储数组，增加空间复杂度	需要准确计算长度和剩余部分	需要额外空间且稍复杂	需要两次遍历，稍增时间开销

应用示例

游戏开发中的角色队列管理：
在多人在线游戏中，经常需要管理玩家的队列，例如在战场游戏中旋转玩家的出场顺序。使用旋转链表的算法可以有效地管理这种动态变化的玩家队列，确保每个玩家都能公平地参与游戏，同时也支持快速的动态调整。