leecode第12天

118.杨辉三角
# 给定一个非负整数 numRows,生成「杨辉三角」的前 numRows 行。
# 在「杨辉三角」中,每个数是它左上方和右上方的数的和。
import copy

class Solution(object):
    def generate(self, numRows):
        """
        生成杨辉三角的前numRows行。
        
        :type numRows: int - 输入的行数
        :rtype: List[List[int]] - 返回一个包含杨辉三角前numRows行的列表的列表
        """
    
        # 如果输入的行数为0,返回空列表
        if numRows==0:
            return []      
        # 如果输入的行数为1,返回包含第一行的列表
        if numRows==1:
            return [[1]]
        # 如果输入的行数为2,返回包含前两行的列表
        if numRows==2:
            return [[1],[1,1]]
        
        # 初始化结果列表,包含杨辉三角的前两行
        res=[[1],[1,1]]
        # 初始化当前行,从第三行开始计算
        cur=[1,1]
        # 从第三行开始,迭代生成杨辉三角的每一行
        for i in range(2,numRows):#2~n-1<====>numRows(3~n)        
            # 深拷贝当前行,用于计算下一行
            temp=copy.deepcopy(cur)
            # 在当前行的末尾添加1
            cur.append(1)
    
            # 计算当前行中间的元素,头尾元素为1,不需要处理
            for j in range(1,i):#头尾为1,不处理
                cur[j]=temp[j-1]+temp[j]  
    
            # 深拷贝计算完成的当前行,用于结果存储
            new=copy.deepcopy(cur)
    
            # 将当前行添加到结果列表中
            res.append(new)
        
        # 返回生成的杨辉三角的前numRows行
        return res
什么需要深拷贝?

深拷贝在该代码中的作用是确保当前行cur的修改不会影响到之前存储的结果。具体原因如下:

  1. 避免引用共享问题:如果直接使用赋值(如temp = cur),tempcur会指向同一个列表对象。后续对cur的修改会同时影响到temp,导致计算错误。
  2. 保持数据独立性:通过copy.deepcopy(cur),创建了cur的一个完全独立的副本temp,这样可以在计算下一行时安全地使用temp中的值,而不受cur变化的影响。
开始
numRows是否为0
返回空列表
numRows是否为1
返回结果
numRows是否为2
返回结果
初始化res和cur
从第3行开始迭代
深拷贝当前行
在当前行末尾添加1
计算当前行中间元素
深拷贝计算完成的行
将新行添加到结果列表
是否完成所有行
返回结果列表
    #leecode
    def generate(self, numRows):
        """
        生成杨辉三角的前numRows行。

        :type numRows: int - 输入的行数
        :rtype: List[List[int]] - 返回一个包含杨辉三角前numRows行的列表的列表
        """
        # 初始化结果列表,其中每一行包含相应数量的1
        res = [[1] * i for i in range(1, numRows + 1)]
        
        # 如果输入的行数小于等于2,直接返回初始化的结果列表
        if numRows <= 2:
            return res
        
        # 从第三行开始,迭代生成杨辉三角的每一行
        for i in range(1, numRows):
            # 计算当前行中间的元素,头尾元素为1,不需要处理
            for j in range(1, i):
                res[i][j] = res[i - 1][j - 1] + res[i - 1][j]
        
        # 返回生成的杨辉三角的前numRows行
        return res
当前提供的引用内容并未涉及 LeetCode 第 25 题的信息。然而,基于已知的 LeetCode 平台题目编号规律以及常见问题分类,可以推测 LeetCode 第 25 题通常是指 **"Reverse Nodes in k-Group"**(k 个一组翻转链表)。以下是关于此问题的专业解答: ### 问题描述 给定一个链表,将其节点按照每 k 个一组进行反转。如果剩余节点不足 k 个,则保持原样。返回修改后的链表。 #### 示例输入输出 ```plaintext Input: head = [1,2,3,4,5], k = 2 Output: [2,1,4,3,5] Input: head = [1,2,3,4,5], k = 3 Output: [3,2,1,4,5] ``` --- ### 解决方案 为了实现这一功能,可以通过迭代的方式处理链表节点组,并利用辅助函数完成单组内的反转操作。具体方法如下: #### 方法概述 1. 使用指针 `start` 和 `end` 定位每一组的第一个和最后一个节点。 2. 对于满足长度为 k 的子链表部分,调用辅助函数对其进行局部反转。 3. 将上一步的结果连接回原始链表结构。 4. 如果最后剩余的部分少于 k 个节点,则不作任何改动。 下面是完整的 Python 实现代码: ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def reverseKGroup(head: ListNode, k: int) -> ListNode: dummy = ListNode(0) dummy.next = head prev_group_end = dummy # 跟踪前一段链表的结尾 while True: # 检查是否有足够的节点来形成下一组 current_node = prev_group_end for _ in range(k): if not current_node.next: return dummy.next current_node = current_node.next # 反转当前组 (prev_group_end.next 到 current_node) new_group_start = prev_group_end.next temp_next = current_node.next prev_group_end.next, current_tail = reverseSubList(new_group_start, k) # 连接反转后的组到整体链表 current_tail.next = temp_next prev_group_end = current_tail def reverseSubList(head: ListNode, count: int) -> tuple[ListNode]: """ 辅助函数:用于反转指定数量的节点 """ previous = None current = head for _ in range(count): next_temp = current.next current.next = previous previous = current current = next_temp return previous, head # 返回新的头结点和旧的头结点作为尾部 ``` 上述算法的时间复杂度为 O(n),其中 n 是链表中节点的数量;空间复杂度为 O(1)[^6]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值