【PythonCode】力扣Leetcode1~5题Python版
共 13105字，需浏览 27分钟
· 2024-04-11
作者通常周更，为了不错过更新，请点击上方“ Python碎片 ”，“ 星标 ”公众号
前言
力扣Leetcode是一个集学习、刷题、竞赛等功能于一体的编程学习平台，很多计算机相关专业的学生、编程自学者、IT从业者在上面学习和刷题。
在Leetcode上刷题，可以选择各种主流的编程语言，如C++、JAVA、Python、Go等。还可以在线编程，实时执行代码，如果代码通过了平台准备的测试用例，就可以通过题目。
本系列中的文章从Leetcode的第1题开始，记录我用Python语言提交的代码和思路，受个人能力限制，只是实现功能通过用例，我没有每题都研究最优的实现方法，供Python学习参考。
1. 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
提示：
2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
代码实现：
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
for j in range(i+1, len(nums)):
if nums[i] + nums[j] == target:
return [i, j]
解题思路：嵌套遍历从数组中取出两个数相加，用嵌套的for循环，判断相加的结果是否满足要求，如果满足则用列表返回两个数据的索引。因为同一个元素不能重复出现，所以索引 j 从 i+1 开始遍历。
2. 两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
代码实现：
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
l1num, l2num = l1.val, l2.val
i, j = 0, 0
cur = l1
while cur.next:
cur = cur.next
i += 1
l1num += cur.val * 10 ** i
cur2 = l2
while cur2.next:
cur2 = cur2.next
j += 1
l2num += cur2.val * 10 ** j
sumnum = l1num + l2num
result = ListNode()
cur = result
for s in str(sumnum)[::-1]:
cur.next = ListNode(int(s))
cur = cur.next
return result.next
解题思路：先按照逆序的方式将 l1 和 l2 两个链表转化成对应的整数，转化时依次将第 i 个节点的数字乘 10 的 i 次方，并全部相加，i 从 0 开始。得到两个整数，计算两个整数之和。然后将整数之和倒序保存到链表中，每个节点一个数字。我采用的方式是将两数之和转换成字符串倒着遍历，再将每个数字转换回整数，然后创建节点添加到链表中。
3. 无重复字符的最长子串
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例1：
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
提示：
0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成
代码实现：
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
length = 0
for i in range(len(s)):
slist = []
for j in range(i, len(s)):
if s[j] not in slist:
slist.append(s[j])
else:
break
length = max(length, len(slist))
return length
解题思路：遍历字符串的索引，以每一个索引位为标志位，从标志位往后找最长的子串。最长子串的判断方式用列表实现，如果连续的字符不在列表中，则添加进列表，遇到重复的字符时跳出内循环。循环结束后计算列表的长度，并更新当前的最长长度。每次移动标志位，清空用于保存字符的列表。
4. 寻找两个正序数组的中位数
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
提示：
nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106
代码实现：
class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
m = len(nums1)
n = len(nums2)
if m > n:
return self.findMedianSortedArrays(nums2,nums1)
k = (m + n + 1)//2
left = 0
right = m
while left < right :
m1 = left +(right - left)//2
m2 = k - m1
if nums1[m1] < nums2[m2-1]:
left = m1 + 1
else:
right = m1
m1 = left
m2 = k - m1
c1 = max(nums1[m1-1] if m1 > 0 else float("-inf"), nums2[m2-1] if m2 > 0 else float("-inf") )
if (m + n) % 2 == 1:
return c1
c2 = min(nums1[m1] if m1 < m else float("inf"), nums2[m2] if m2 <n else float("inf"))
return (c1 + c2) / 2
解题思路：此题在Leetcode上的难度是困难，属于等级最高的难度（简单、中等、困难），困难的原因是要求时间复杂度为O(log (m+n))。主要目的是考算法思路，并且要提交者自己实现算法。如果没有时间复杂度的要求，实现其实很简单，如下代码就可以通过力扣的用例(甚至可以更简单，导入一个求中位数的函数)：
class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
nums = sorted(nums1 + nums2)
if len(nums) % 2 == 0:
return (nums[int(len(nums) // 2) - 1] + nums[int(len(nums) // 2)]) / 2
else:
return nums[len(nums) // 2]
因为要求时间复杂度为 O(log (m+n))，我一开始也没有想到好的方法，所以参考了力扣用户powcai的答案。两个数组都是正序排列的，所以找到中位数的策略是从两个数组中找出排序在前一半的数据，中间的数字就是中位数。也就是找出第 k 大的那个数字，k 是两个数组长度之和的一半，或中间的两个数（k, k+1）。
假如使用遍历，时间复杂度将会是 O(m+n)，为了将时间复杂度降到题目要求的O(log (m+n))，需要使用二分法的方式查找。遍历是每次排除一个数据不是第 k 大，二分查找每次排除 k/2 个数据不是第 k 大。在这个思路的基础上，结合上面的代码就可以分析出解题办法了。如果你需要了解更详细的解题细节，可以自己再搜索更多的参考答案。
5. 最长回文子串
给你一个字符串 s，找到 s 中最长的回文子串。
如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。
示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
提示：
1 <= s.length <= 1000 s 仅由数字和英文字母组成
代码实现：
class Solution:
def longestPalindrome(self, s: str) -> str:
max_length = 1
start_index = 0
i = 0
while i < len(s):
length = 1
left = i - 1
while left >= 0 and s[left] == s[i]:
length += 1
left -= 1
right = i + 1
while right < len(s) and s[right] == s[i]:
length += 1
right += 1
i += 1
while left >= 0 and right < len(s) and s[left] == s[right]:
length += 2
left -= 1
right += 1
if length > max_length:
max_length = length
start_index = left+1
i += 1
return s[start_index:start_index+max_length]
解题思路：要找到字符串 s 中的最长回文子串，需要找到最长回文子串的长度 max_length 和回文子串的开始索引 start_index 。因为 s 的长度最短为1，所以 max_length 最小为 1，start_index 初始为 0，以此为初始值，当找到更长的回文子串时更新两者的值。
遍历字符串的每一个字符，以每一个字符为标志位，判断标志位左侧的字符是否与标志位的字符相同，如果相同则继续向左找，每找到一个字符，回文子串的长度加1，右侧也同理。这样可以找到标志位两侧与标志位相同的所有连续字符，包含了奇数个和偶数个两种情况。
找完与标志位相同的连续字符后，再继续找左边的字符与右边的字符相同的情况，此时每找到一对相同的字符，回文子串的长度加2，直到两边的字符不同或到达字符串 s 的边界。完成后判断此次找到的最长回文长度和前面找到的长度，如果更长就更新 max_length 和 start_index 的值。
进阶：本文使用 while 循环，在向右找到与标志位相同的连续字符时，标志位的索引 i 也加1，这样可以减少 while 的遍历次数，提高程序的运行效率，跑Leetcode上提供的用例可以缩短5倍左右的时间。（同时，在这种方式的循环中，不需要向左寻找与标志位相同的连续字符，代码不会执行到。上面还保留着向左寻找的代码，是为了与解题思路保持一致，方便理解。）
相关阅读👉
分享
收藏
点赞
在看