python两个不等长的数组不能相加_Python小白 Leetcode刷题历程 No.1-No.5 两数之和、两数相加、无重复字符的最长子串、寻找两个有序数组的中位数、最长回文子串（有...

最新推荐文章于 2022-12-09 10:45:59 发布

一土水丰色今口

最新推荐文章于 2022-12-09 10:45:59 发布

阅读量839

点赞数

文章标签： python两个不等长的数组不能相加

本文链接：https://blog.csdn.net/weixin_26789847/article/details/112033674

版权

本文记录了一位计算机院学生使用Python在LeetCode上刷题的过程，从简单题目的两数之和，到中等难度的两数相加和无重复字符的最长子串，再到困难级别的寻找两个有序数组的中位数和最长回文子串。文中给出了每道题的解题思路和Python3.8代码实现，适合编程初学者参考。

摘要由CSDN通过智能技术生成

Python小白 Leetcode刷题历程 No.1-No.5 两数之和、两数相加、无重复字符的最长子串、寻找两个有序数组的中位数、最长回文子串

写在前面：

作为一个计算机院的大学生，总觉得仅仅在学校粗略的学习计算机专业课是不够的，尤其是假期大量的空档期，作为一个小白，实习也莫得路子，又不想白白耗费时间。于是选择了Leetcode这个平台来刷题库。编程我只学过基础的C语言，现在在自学Python，所以用Python3.8刷题库。现在我Python掌握的还不是很熟练，算法什么的也还没学，就先不考虑算法上的优化了，单纯以解题为目的，复杂程度什么的以后有时间再优化。计划顺序五个题写一篇日志，希望其他初学编程的人起到一些帮助，写算是对自己学习历程的一个见证了吧。

有一起刷LeetCode的可以关注我一下，我会一直发LeetCode题库Python3解法的，也可以一起探讨。

觉得有用的话可以点赞关注下哦，谢谢大家！

········································································································································································

题解框架：

1.题目，难度

2.题干,题目描述

3.题解代码(Python3(不是Python，是Python3))

4.或许有用的知识点(不一定有)

5.解题思路

6.优解代码及分析(当我发现有比我写的好很多的代码和思路我就会写在这里)

No.1.两数之和

难度：简单

题目描述：

在这里插入图片描述

题解代码(Python3.8)

class Solution:

def twoSum(self, nums: List[int], target: int) -> List[int]:

for i in range(len(nums)-1):

for j in range(i+1,len(nums)):

if nums[i] + nums[j] == target:

return [i,j]

解题思路：

暴力方法，运用两个for循环遍历数组完成表达式s[i] + s[j]的遍历，因为加法不用区分s[i]和s[j]的顺序，因此i属于range(len(nums)-1)，j属于range(i+1,len(nums))，判断是否有s[i] + s[j] = sum即可，因为只需要返回[i,j],所以只需要在两个for循环内return [i,j]即可跳出两层for循环。

No.2.两数相加

难度：中等

题目描述：

在这里插入图片描述

题解代码(Python3.8)

class Solution:

def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:

def add(a,b,c):

if not( a or b ):

return ListNode(1) if c else None

a = a if a else ListNode(0)

b = b if b else ListNode(0)

val = a.val + b.val + c

c= val/10 if val>=10 else 0

a.val = val%10

a.next = add(a.next,b.next,int(c))

return a

return add(l1,l2,0)

或许有用的知识点：

ListNode的一些介绍：

变量值=List Node.val

指针指向下一节点=List Node.next

在这里插入图片描述

解题思路：

这个其实可以类比加法器，两个List Node中每一位相加，得到一个结果和一个进位，结果存在L1中该位上，进位加在L1..next上。我们可以把这一过程定义为函数add，然后对add进行递归即可。

No.3.无重复字符的最长子串

难度：中等

题目描述：

在这里插入图片描述

题解代码(Python3.8)

class Solution:

def lengthOfLongestSubstring(self, s: str) -> int:

if not s:

return 0

left = 0

lookup = set() #定义为set形式去重

max_len = 0

cur_len = 0

for i in range(len(s)):

cur_len += 1

while s[i] in lookup:

lookup.remove(s[left])

left += 1

cur_len -= 1

if cur_len > max_len:

max_len = cur_len

lookup.add(s[i])

return max_len

或许有用的知识点：

set(list)函数可以将list中重复元素过滤，set是无序的，set.add(key)可以在set中添加元素，set.remove(key)可以在set中删除元素。

滑动窗口：其实就是一个队列,比如例题中的 abcabcbb，进入这个队列(窗口)为 abc 满足题目要求，当再进入 a，队列变成了 abca，这时候不满足要求。所以，我们要移动这个队列！我们只要把队列的左边的元素移出就行了，直到满足题目要求！一直维持这样的队列，找出队列出现最长的长度时候，求出解！

解题思路：

暴力方法，先单列出len(s)=0和len(s)=1的情况，再对其他情况进行循环求解。设置一个起始位置下标j=0，一重for循环遍历i in range(1,len(s)),第二重for循环遍历m in range(j,i)。再把k置零，第二重循环中，每次s[m] != s[i] 则k++，若k == i-j 则说明s[j]到s[i]无重复字符，将将其长度与max1比较即可。若出现s[m] == s[i]则令j=m+1，k置零。

NO.4.寻找两个有序数组的中位数

难度：困难

题目描述:

在这里插入图片描述

题解代码(Python3.8)

class Solution:

def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:

n=len(nums1)+len(nums2)

nums1=nums1+nums2

nums1.sort()

if n%2 != 0:

num = nums1[(n-1)//2]

else:

num = (nums1[n//2]+nums1[(n//2)-1])/2

return num

或许有用的知识点：

看到了复杂度为O(log(m+n))和有序数列，不难想到使用「二分查找」来解决。

这是408考试的原题，含金量还是比较高的。

解题思路：

按题目要求，复杂度应为 O(log(m + n))，应采用二分算法，当时我还没学过，就直接冒泡排序了。

这道题应该是难在算法上，我没考虑算法，冒泡排序完按奇偶项取中位数即可。

优解代码及分析：

优解代码(Python3.8)

class Solution:

def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:

m, n = len(nums1), len(nums2)

# 这里为了保证nums1一定是长度较小的数组

if m > n:

nums1, nums2, m, n = nums2, nums1, n, m

# 题目给定数组不会同时为空，也就是m^2+n^2≠0，由于m≤n，故只要n≠0即可

if not n:

raise ValueError("数组长度不同时为零")

i_min, i_max = 0, m

# left集合元素数量，如果m+n是奇数，left比right多一个数据

count_of_left = (m + n + 1) // 2

while i_min <= i_max:

i = (i_min + i_max) // 2 # left有i个nums1的元素

j = count_of_left - i # left有j个nums2的元素

if i > 0 and nums1[i - 1] > nums2[j]:

i_max = i - 1 # i太大，要减少

elif i < m and nums1[i] < nums2[j - 1]:

i_min = i + 1 # i太小，要增加

else:

if i == 0:

max_of_left = nums2[j - 1]

elif j == 0:

max_of_left = nums1[i - 1]

else:

max_of_left = max(nums1[i - 1], nums2[j - 1])

if (m + n) % 2:

return float(max_of_left) # 结果是浮点数

if i == m:

min_of_right = nums2[j]

elif j == n:

min_of_right = nums1[i]

else:

min_of_right = min(nums1[i], nums2[j])

return (max_of_left + min_of_right) / 2.0 # 结果为浮点数

分析：

在这里插入图片描述

No.5.最长回文子串

难度：中等

题目描述：

在这里插入图片描述

题解代码(Python3.8)

class Solution:

def longestPalindrome(self, s: str) -> str:

l=len(s)

if l==0:

sm=""

if l==1 or s[::]==s[::-1]:

sm=s

else:

dm=1

sm=s[0]

l=len(s)

for i in range(l-1):

for j in range(i+1,l):

d=j-i+1

if d>dm:

if (i+j)%2 == 0:

if s[i: (i+j)//2 ] == s[j: (i+j)//2 :-1]:

sm=s[i:j+1]

dm=d

else:

if s[i: ((i+j)//2)+1 ] == s[j: (i+j)//2 :-1]:

sm=s[i:j+1]

dm=d

return sm

或许有用的知识点：

切片操作：通常一个切片操作要提供三个参数 [start_index: stop_index: step] ：

start_index是切片的起始位置

stop_index是切片的结束位置(不包括)

step可以不提供，默认值是1，步长值不能为0，不然会报错ValueError。

在这里插入图片描述

这道题会用到动态规划的知识。

在这里插入图片描述

dp = [[False for _ in range(size)] for _ in range(size)]可以理解为Python创建二维数组的一种写法。

解题思路

对于没有算法基础的我来说，Python的切片功能极其好用，他为我减少了一阶的复杂度。我们先用两个for循环遍历所有的s[i]到s[j]区间，对其正向切片和反向切片，若值相同，即为一个回文子串，与最长回文子串比较长度即可。

优解代码及分析：

优解代码(Python3.8)

class Solution:

def longestPalindrome(self, s: str) -> str:

size = len(s)

if size < 2:

return s

dp = [[False for _ in range(size)] for _ in range(size)]

max_len = 1

start = 0

for i in range(size):

dp[i][i] = True

for j in range(1, size):

for i in range(0, j):

if s[i] == s[j]:

if j - i < 3:

dp[i][j] = True

else:

dp[i][j] = dp[i + 1][j - 1]

else:

dp[i][j] = False

if dp[i][j]:

cur_len = j - i + 1

if cur_len > max_len:

max_len = cur_len

start = i

return s[start:start + max_len]

分析：

1、思考状态

状态先尝试“题目问什么，就把什么设置为状态”。然后考虑“状态如何转移”，如果“状态转移方程”不容易得到，尝试修改定义，目的仍然是为了方便得到“状态转移方程”。

2、思考状态转移方程(核心、难点)

状态转移方程是非常重要的，是动态规划的核心，也是难点，起到承上启下的作用。

技巧是分类讨论。对状态空间进行分类，思考最优子结构到底是什么。即大问题的最优解如何由小问题的最优解得到。

归纳“状态转移方程”是一个很灵活的事情，得具体问题具体分析，除了掌握经典的动态规划问题以外，还需要多做题。如果是针对面试，请自行把握难度，我个人觉得掌握常见问题的动态规划解法，明白动态规划的本质就是打表格，从一个小规模问题出发，逐步得到大问题的解，并记录过程。动态规划依然是“空间换时间”思想的体现。

3、思考初始化

初始化是非常重要的，一步错，步步错，初始化状态一定要设置对，才可能得到正确的结果。

角度 1：直接从状态的语义出发；

角度 2：如果状态的语义不好思考，就考虑“状态转移方程”的边界需要什么样初始化的条件；

角度 3：从“状态转移方程”方程的下标看是否需要多设置一行、一列表示“哨兵”，这样可以避免一些边界的讨论，使得代码变得比较短。

4、思考输出

有些时候是最后一个状态，有些时候可能会综合所有计算过的状态。

5、思考状态压缩

“状态压缩”会使得代码难于理解，初学的时候可以不一步到位。先把代码写正确，然后再思考状态压缩。

状态压缩在有一种情况下是很有必要的，那就是状态空间非常庞大的时候(处理海量数据)，此时空间不够用，就必须状态压缩。

这道题比较烦人的是判断回文子串。因此需要一种能够快速判断原字符串的所有子串是否是回文子串的方法，于是想到了“动态规划”。

“动态规划”最关键的步骤是想清楚“状态如何转移”，事实上，“回文”是天然具有“状态转移”性质的：