[Datawhale打卡]数据结构与算法简介、LeetCode 入门及攻略

基本概念

LeetCode懒人小白刷题攻略

[算法通关手册」电子书网站地址：https://algo.itcharge.cn

照着datawhale大佬们的攻略刷

Exercises

2235. 两整数相加

def target_sum(num1, num2):
    return num1 + num2

T(n) = O(1), S(n) = O(1)

1929. 数组串联

def get_concatenation(nums):
    ans = nums
    for i in range(len(nums)):
        ans.append(nums[i])
    return ans

T(n) = O(n)

• 创建ans的操作是 O(n)，因为它需要复制 nums 列表中的所有元素。
• 循环遍历 nums 并追加每个元素到 ans 列表中也是 O(n)，因为需要遍历一次 nums 中的所有元素。 所以，总的时间复杂度是 O(n) + O(n)，简化后仍然是 O(n)

S(n) = O(n)

• 创建 nums 的副本需要 O(n) 的额外空间来存储这些元素。 所以，空间复杂度是 O(n)。

0771. 宝石与石头

def num_jewels_in_stones(jewels,stones):
    count = 0
    for s in stones:
        if s in jewels:
            count += 1
    return count

T(n) = O(m*n)

• 遍历 stones 字符串中的每个字符，这个操作的时间复杂度是 O(m)，其中 m 是 stones 字符串的长度。
• 对于 stones 字符串中的每个字符，我们需要检查它是否出现在 jewels 字符串中。在最坏的情况下（即 jewels 包含所有可能的字符），这个检查操作的时间复杂度是 O(n)，其中 n 是 jewels 字符串的长度。
• 总的时间复杂度是 O(m * n)

S(n) = O(1)

• 使用了一个计数变量 count，它是一个单独的整数，所以空间复杂度是 O(1)

1480. 一维数组的动态和

def running_sum(nums):
    result = []
    for i in range(len(nums)):
        result.append(sum(nums[:i+1]))
    return result

T(n) = O(n^2)

• for 循环会遍历 nums 列表中的每个元素，因此循环的次数为 n，其中 n 是 nums 的长度。
• 在每次循环中，sum(nums[:i+1]) 计算了 nums 从开始到当前索引 i（包括 i）的累积和。由于 sum 函数需要遍历从列表开始到索引 i 的所有元素，这部分的时间复杂度是 i。
• 由于 i 从 1 增加到 n，所以累积的时间复杂度是 1 + 2 + 3 + ... + n，这是一个等差数列求和的公式，结果为 n(n+1)/2，简化后是 O(n^2)。
• 改进之后时间复杂度减为O(n)

• def running_sum(nums):
      result = []
      current_sum = 0
      for num in nums:
          current_sum += num
          result.append(current_sum)
      return result

S(n) = O(n)

• result 列表会存储所有累积和，其大小与输入列表 nums 相同，因此需要 O(n) 的空间。

0709. 转换成小写字母

def to_lower_case(s):
    c = ''
    for char in s:
        if char.isupper():
            c +=char.lower()
        else:
            c += char
    return c

T(n) = O(n)

• 函数中的 for 循环会遍历输入字符串 s 中的每个字符，因此循环的次数为 n，其中 n是 s 的长度。
• 在每次循环中，对字符进行大小写转换的操作（char.lower()）是一个常数时间操作，即 O(1)。
• 总的时间复杂度是 O(n)，其中 n是输入字符串 s 的长度。

S(n) = O(n)

• c 字符串用于存储转换后的结果，其长度与输入字符串 s 相同

1672. 最富有客户的资产总量

def maximum_wealth(accounts):
    result = 0
    for i in range(len(accounts)):
        if result < sum(accounts[i]):
            result = sum(accounts[i])
    return result

T(n) = O(m*n)

• for 循环会遍历 accounts 列表中的每个子列表，因此循环的次数为 n，其中 n 是 accounts 中子列表的数量
• 在每次循环中，sum(accounts[i]) 计算了当前子列表 accounts[i] 中所有元素的和，这个操作的时间复杂度是 O(m)，其中 m 是子列表 accounts[i] 的长度。
• 总的时间复杂度是O(nm)

S(n) = O(1)

• 使用单个变量 result 来存储最大财富值，因此空间复杂度是 O(1)

 

reference:LeetCode 算法笔记