python5种算法模拟螺旋、分层填充、递归、迭代、分治实现螺旋矩阵ll【力扣题59】

简介: python5种算法模拟螺旋、分层填充、递归、迭代、分治实现螺旋矩阵ll【力扣题59】

作者介绍:10年大厂数据\经营分析经验,现任大厂数据部门负责人。

会一些的技术:数据分析、算法、SQL、大数据相关、python

欢迎加入社区:码上找工作

作者专栏每日更新:

LeetCode解锁1000题: 打怪升级之旅

python数据分析可视化:企业实战案例

备注说明:方便大家阅读,统一使用python,带必要注释,公众号 数据分析螺丝钉 一起打怪升级

题目描述

给你一个正整数 n,生成一个包含 1n^2 所有元素的 n x n 正方形矩阵,数组的元素按螺旋顺序依次填充。

输入格式
  • n:一个正整数,表示矩阵的大小。
输出格式
  • 返回一个 n x n 的数组,按螺旋顺序填充从 1n^2 的整数。
示例 1
输入: n = 3
输出: [[1,2,3],[8,9,4],[7,6,5]]

方法一:模拟螺旋填充

解题步骤
  1. 初始化矩阵:创建一个 n x n 的矩阵,初始填充值为 0
  2. 螺旋遍历:定义四个方向,模拟螺旋遍历的过程,按顺序填入数字。
  3. 边界条件处理:在填充过程中,需要不断检查下一个位置是否超出边界或已被填充。
完整的规范代码
def generateMatrix(n):
    """
    使用模拟螺旋遍历的方法生成螺旋矩阵
    :param n: int, 矩阵的大小
    :return: List[List[int]], 螺旋矩阵
    """
    matrix = [[0] * n for _ in range(n)]
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]  # right, down, left, up
    row, col, di = 0, 0, 0
    for i in range(1, n*n + 1):
        matrix[row][col] = i
        dr, dc = directions[di]
        if not (0 <= row + dr < n and 0 <= col + dc < n and matrix[row + dr][col + dc] == 0):
            di = (di + 1) % 4  # Change direction
            dr, dc = directions[di]
        row, col = row + dr, col + dc
    return matrix
# 示例调用
print(generateMatrix(3))  # 输出: [[1, 2, 3], [8, 9, 4], [7, 6, 5]]
算法分析
  • 时间复杂度:(O(n^2)),其中 n 是矩阵的维度,需要填充 n^2 个元素。
  • 空间复杂度:(O(n^2)),用于存储生成的矩阵。

方法二:分层填充法

解题步骤
  1. 定义边界:设置上下左右四个边界,控制填充范围。
  2. 外层到内层填充:按层模拟填充过程,每完成一圈缩小填充范围。
  3. 逐层填充:按照右下左上的顺序逐层填充,每填完一全圈,四个边界向内缩进。
完整的规范代码
def generateMatrix(n):
    """
    使用分层填充法生成螺旋矩阵
    :param n: int, 矩阵的大小
    :return: List[List[int]], 螺旋矩阵
    """
    matrix = [[0] * n for _ in range(n)]
    left, right, top, bottom = 0, n-1, 0, n-1
    num = 1
    while left <= right and top <= bottom:
        for i in range(left, right + 1):
            matrix[top][i] = num
            num += 1
        top += 1
        for i in range(top, bottom + 1):
            matrix[i][right] = num
            num += 1
        right -= 1
        if top <= bottom:
            for i in range(right, left - 1, -1):
                matrix[bottom][i] = num
                num += 1
            bottom -= 1
        if left <= right:
            for i in range(bottom, top - 1, -1):
                matrix[i][left] = num
                num += 1
            left += 1
    return matrix
# 示例调用
print(generateMatrix(3))  # 输出: [[1, 2, 3], [8, 9, 4], [7, 6, 5]]
算法分析
  • 时间复杂度:(O(n^2)),必须填充所有 n^2 个元素。
  • 空间复杂度:(O(n^2)),用于存储生成的矩阵。

方法三:递归填充

解题步骤
  1. 递归函数定义:定义一个递归函数用于填充每一层。
  2. 递归填充:从外层向内层递归填充,每次递归填充一圈。
  3. 终止条件:当填充完成或只剩下一行/一列时终止递归。
完整的规范代码
def generateMatrix(n):
    """
    使用递归方法生成螺旋矩阵
    :param n: int, 矩阵的大小
    :return: List[List[int]], 螺旋矩阵
    """
    matrix = [[0] * n for _ in range(n)]
    fill(matrix, 0, n, 1)
    return matrix
def fill(matrix, start, n, val):
    if n <= 0:
        return
    if n == 1:
        matrix[start][start] = val
        return
    for i in range(n - 1):
        matrix[start][start + i] = val
        val += 1
    for i in range(n - 1):
        matrix[start + i][start + n - 1] = val
        val += 1
    for i in range(n - 1):
        matrix[start + n - 1][start + n - 1 - i] = val
        val += 1
    for i in range(n - 1):
        matrix[start + n - 1 - i][start] = val
        val += 1
    fill(matrix, start + 1, n - 2, val)
# 示例调用
print(generateMatrix(3))  # 输出: [[1, 2, 3], [8, 9, 4], [7, 6, 5]]
算法分析
  • 时间复杂度:(O(n^2)),需要填充所有 n^2 个元素。
  • 空间复杂度:(O(n^2)),用于存储生成的矩阵,加上递归栈的开销(最坏情况下为 (O(n)))。

方法四:迭代展开

解题步骤
  1. 初始化变量:定义矩阵、起始点、方向等变量。
  2. 迭代填充:通过迭代的方式填充矩阵,类似于方法一但避免了方向切换的复杂判断。
  3. 边界处理:在迭代中处理矩阵边界和已填充元素的情况。
完整的规范代码
def generateMatrix(n):
    """
    使用迭代展开的方法生成螺旋矩阵
    :param n: int, 矩阵的大小
    :return: List[List[int]], 螺旋矩阵
    """
    matrix = [[0] * n for _ in range(n)]
    x, y, dx, dy = 0, 0, 0, 1
    for i in range(1, n*n+1):
        matrix[x][y] = i
        if matrix[(x+dx)%n][(y+dy)%n]:
            dx, dy = dy, -dx
        x, y = x + dx, y + dy
    return matrix
# 示例调用
print(generateMatrix(3))  # 输出: [[1, 2, 3], [8, 9, 4], [7, 6, 5]]
算法分析
  • 时间复杂度:(O(n^2)),需要填充所有 n^2 个元素。
  • 空间复杂度:(O(n^2)),用于存储生成的矩阵。

方法五:分治填充

解题步骤
  1. 定义填充函数:创建一个函数用于填充矩阵的一圈。
  2. 分治递归:递归地填充外圈后,对内层矩阵进行相同操作。
  3. 终止与初始化:当矩阵大小减小到1或0时终止递归。
完整的规范代码
def generateMatrix(n):
    """
    使用分治填充法生成螺旋矩阵
    :param n: int, 矩阵的大小
    :return: List[List[int]], 螺旋矩阵
    """
    matrix = [[0] * n for _ in range(n)]
    fill_layer(matrix, 0, n, 1)
    return matrix
def fill_layer(matrix, start, size, start_val):
    if size <= 0:
        return
    if size == 1:
        matrix[start][start] = start_val
        return
    # Fill the perimeter
    for i in range(size - 1):
        matrix[start][start+i] = start_val
        start_val += 1
    for i in range(size - 1):
        matrix[start+i][start+size-1] = start_val
        start_val += 1
    for i in range(size - 1):
        matrix[start+size-1][start+size-1-i] = start_val
        start_val += 1
    for i in range(size - 1):
        matrix[start+size-1-i][start] = start_val
        start_val += 1
    fill_layer(matrix, start+1, size-2, start_val)
# 示例调用
print(generateMatrix(3))  # 输出: [[1, 2, 3], [8, 9, 4], [7, 6, 5]]
算法分析
  • 时间复杂度:(O(n^2)),需要填充所有 n^2 个元素。
  • 空间复杂度:(O(n^2)),用于存储生成的矩阵,递归栈深度依矩阵大小而定。

不同算法的优劣势对比

特征 方法一: 模拟螺旋填充 方法二: 分层填充法 方法三: 递归填充 方法四: 迭代展开 方法五: 分治填充
时间复杂度 (O(n^2)) (O(n^2)) (O(n^2)) (O(n^2)) (O(n^2))
空间复杂度 (O(n^2)) (O(n^2)) (O(n^2)) (O(n^2)) (O(n^2))
优势 直观易理解 清晰结构化 结构简单 代码简洁 递归清晰,易于理解
劣势 稍微复杂的控制流 多次循环 递归深度问题 边界处理复杂 空间使用多,递归深度

应用示例

游戏开发

在游戏开发中,尤其是需要生成迷宫或特定图案的场景设计里,螺旋矩阵可以用于设计关卡的地图布局,例如生成螺旋迷宫地图,增加游戏的趣味性和挑战性。

通过上述方法,开发者可以选择最适合其应用场景的算法来实现高效、可靠的矩阵生成功能。

欢迎关注微信公众号 数据分析螺丝钉

目录
打赏
0
5
5
0
68
分享
相关文章
基于Python深度学习的眼疾识别系统实现~人工智能+卷积网络算法
眼疾识别系统,本系统使用Python作为主要开发语言,基于TensorFlow搭建卷积神经网络算法,并收集了4种常见的眼疾图像数据集(白内障、糖尿病性视网膜病变、青光眼和正常眼睛) 再使用通过搭建的算法模型对数据集进行训练得到一个识别精度较高的模型,然后保存为为本地h5格式文件。最后使用Django框架搭建了一个Web网页平台可视化操作界面,实现用户上传一张眼疾图片识别其名称。
307 5
基于Python深度学习的眼疾识别系统实现~人工智能+卷积网络算法
算法系列之分治算法
分治算法(Divide and Conquer)是一种解决复杂问题的非常实用的策略,广泛应用于计算机科学中的各个领域。它的核心思想是将一个复杂的问题分解成若干个相同或相似的子问题,递归地解决这些子问题,然后将子问题的解合并,最终得到原问题的解。分治算法的典型应用包括归并排序、快速排序、二分查找等。
131 72
 算法系列之分治算法
|
24天前
|
员工电脑监控场景下 Python 红黑树算法的深度解析
在当代企业管理范式中,员工电脑监控业已成为一种广泛采用的策略性手段,其核心目标在于维护企业信息安全、提升工作效能并确保合规性。借助对员工电脑操作的实时监测机制,企业能够敏锐洞察潜在风险,诸如数据泄露、恶意软件侵袭等威胁。而员工电脑监控系统的高效运作,高度依赖于底层的数据结构与算法架构。本文旨在深入探究红黑树(Red - Black Tree)这一数据结构在员工电脑监控领域的应用,并通过 Python 代码实例详尽阐释其实现机制。
40 6
如何在Python下实现摄像头|屏幕|AI视觉算法数据的RTMP直播推送
本文详细讲解了在Python环境下使用大牛直播SDK实现RTMP推流的过程。从技术背景到代码实现,涵盖Python生态优势、AI视觉算法应用、RTMP稳定性及跨平台支持等内容。通过丰富功能如音频编码、视频编码、实时预览等,结合实际代码示例,为开发者提供完整指南。同时探讨C接口转换Python时的注意事项,包括数据类型映射、内存管理、回调函数等关键点。最终总结Python在RTMP推流与AI视觉算法结合中的重要性与前景,为行业应用带来便利与革新。
102 5
基于IEKF迭代扩展卡尔曼滤波算法的数据跟踪matlab仿真,对比EKF和UKF
本项目基于MATLAB2022A实现IEKF迭代扩展卡尔曼滤波算法的数据跟踪仿真,对比EKF和UKF的性能。通过仿真输出误差收敛曲线和误差协方差收敛曲线,展示三种滤波器的精度差异。核心程序包括数据处理、误差计算及可视化展示。IEKF通过多次迭代线性化过程,增强非线性处理能力;UKF避免线性化,使用sigma点直接处理非线性问题;EKF则通过一次线性化简化处理。
113 14
从集思录可转债数据探秘:Python与C++实现的移动平均算法应用
本文探讨了如何利用移动平均算法分析集思录提供的可转债数据,帮助投资者把握价格趋势。通过Python和C++两种编程语言实现简单移动平均(SMA),展示了数据处理的具体方法。Python代码借助`pandas`库轻松计算5日SMA,而C++代码则通过高效的数据处理展示了SMA的计算过程。集思录平台提供了详尽且及时的可转债数据,助力投资者结合算法与社区讨论,做出更明智的投资决策。掌握这些工具和技术,有助于在复杂多变的金融市场中挖掘更多价值。
83 12
基于 Python 的布隆过滤器算法在内网行为管理中的应用探究
在复杂多变的网络环境中,内网行为管理至关重要。本文介绍布隆过滤器(Bloom Filter),一种高效的空间节省型概率数据结构,用于判断元素是否存在于集合中。通过多个哈希函数映射到位数组,实现快速访问控制。Python代码示例展示了如何构建和使用布隆过滤器,有效提升企业内网安全性和资源管理效率。
67 9
内网桌面监控软件深度解析:基于 Python 实现的 K-Means 算法研究
内网桌面监控软件通过实时监测员工操作,保障企业信息安全并提升效率。本文深入探讨K-Means聚类算法在该软件中的应用,解析其原理与实现。K-Means通过迭代更新簇中心,将数据划分为K个簇类,适用于行为分析、异常检测、资源优化及安全威胁识别等场景。文中提供了Python代码示例,展示如何实现K-Means算法,并模拟内网监控数据进行聚类分析。
75 10
控制局域网上网软件之 Python 字典树算法解析
控制局域网上网软件在现代网络管理中至关重要,用于控制设备的上网行为和访问权限。本文聚焦于字典树(Trie Tree)算法的应用,详细阐述其原理、优势及实现。通过字典树,软件能高效进行关键词匹配和过滤,提升系统性能。文中还提供了Python代码示例,展示了字典树在网址过滤和关键词屏蔽中的具体应用,为局域网的安全和管理提供有力支持。
76 17
解锁文档管理系统高效检索奥秘:Python 哈希表算法探究
在数字化时代,文档管理系统犹如知识宝库,支撑各行各业高效运转。哈希表作为核心数据结构,通过哈希函数将数据映射为固定长度的哈希值,实现快速查找与定位。本文聚焦哈希表在文档管理中的应用,以Python代码示例展示其高效检索特性,并探讨哈希冲突解决策略,助力构建智能化文档管理系统。

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等