[LeetCode 热题 HOT 100]1、2、3、4
[LeetCode 热题 HOT 100]1、2、3、4
学习使用工具
🔥 LeetCode 热题 HOT 100 https://leetcode.cn/problem-list/2cktkvj/?page=1
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- 只会存在一个有效答案
进阶：你可以想出一个时间复杂度小于 O(n^2) 的算法吗？
解法：
暴搜，暴搜！
def twoSum(self, nums: List[int], target: int) -> List[int]:
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
return []
先排序再用双指针可以将时间复杂度降低到O(NlogN)，开辟一个temp数组用来记录原数组的下标位置的变化。
def twoSum(self, nums: List[int], target: int) -> List[int]:
temp = [i for i in range(len(nums))]
def sort(i, j):
if i >= j :
return
key = nums[i]
tmp = temp[i]
l = i
r = j
while l < r:
while l < r and nums[r] >= key:
r -= 1
nums[l] = nums[r]
temp[l] = temp[r]
while l < r and nums[l] <= key:
l += 1
nums[r] = nums[l]
temp[r] = temp[l]
nums[l] = key
temp[l] = tmp
sort(i, l)
sort(l + 1, j)
i = 0
j = len(nums) - 1
sort(i, j)
while i <= j:
if nums[i] + nums[j] < target:
i += 1
elif nums[i] + nums[j] > target:
j -= 1
else:
break
return [temp[i], temp[j]]
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 -
题目数据保证列表表示的数字不含前导零
解法：
处理好进位即可。
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
if not l1:
return l2
if not l2:
return l1
l1.val += l2.val
if l1.val >= 10 :
l1.next = self.addTwoNumbers(l1.next, ListNode(l1.val // 10))
l1.val %= 10
l1.next = self.addTwoNumbers(l1.next, l2.next)
return l1
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 * 104s由英文字母、数字、符号和空格组成
解法：
剑指做过，滑动窗口即可。
def lengthOfLongestSubstring(self, s: str) -> int:
gather, r, ans = set(), 0, 0
for l in range(len(s)):
while r < len(s) and not s[r] in gather:
gather.add(s[r])
r += 1
ans = max(ans, r - l)
gather.remove(s[l])
return ans
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 == mnums2.length == n0 <= m <= 10000 <= n <= 10001 <= m + n <= 2000-106 <= nums1[i], nums2[i] <= 106
解法：
说得好，我选择排序加sort。
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
nums1.extend(nums2)
nums1.sort()
if not nums1:
return None
elif len(nums1) == 1:
return nums1[0]
else:
if len(nums1) % 2 == 0:
return (nums1[len(nums1) // 2] + nums1[len(nums1) // 2 - 1]) / 2.0
return nums1[len(nums1) // 2]
时间复杂度带对数的基本都考虑用二分求解。
根据中位数的定义，这道题可以转化成寻找两个有序数组中的第 \(k\) 小的数。
假设两个有序数组分别是 A 和 B。要找到第 k 个元素，我们可以比较 A[k/2−1] 和 B[k/2−1]：
- 如果 \(A[k/2−1]<=B[k/2−1]\)，则比 \(A[k/2−1]\) 小的数最多只有 A 的前 k/2−1 个数和 B 的前 \(k/2−1\) 个数，即比 \(A[k/2−1]\) 小的数最多只有 \(k−2\)个，因此 \(A[k/2−1]\) 不可能是第 \(k\) 个数，\(A[k/2-1]\)以及之前的数都可以全部排除。
- 如果 \(A[k/2−1]>B[k/2−1]\)，则可以排除 \(B[0]\) 到 \(B[k/2−1]\)。
边界条件：
- 如果 \(A[k/2−1]\) 或者 \(B[k/2−1]\) 越界，选取对应数组中的最后一个元素。在这种情况下，根据排除数的个数减少 \(k\) 的值。
- 如果一个数组为空，返回另一个数组中第 k 小的元素。
- 如果 k=1，返回两个数组首元素的最小值。
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
def getKthElement(k):
index1, index2 = 0, 0
while True:
# 特殊情况
if index1 == m:
return nums2[index2 + k - 1]
if index2 == n:
return nums1[index1 + k - 1]
if k == 1:
return min(nums1[index1], nums2[index2])
# 正常情况
newIndex1 = min(index1 + k // 2 - 1, m - 1)
newIndex2 = min(index2 + k // 2 - 1, n - 1)
pivot1, pivot2 = nums1[newIndex1], nums2[newIndex2]
if pivot1 <= pivot2:
k -= newIndex1 - index1 + 1
index1 = newIndex1 + 1
else:
k -= newIndex2 - index2 + 1
index2 = newIndex2 + 1
m, n = len(nums1), len(nums2)
totalLength = m + n
if totalLength % 2 == 1:
return getKthElement((totalLength + 1) // 2)
else:
return (getKthElement(totalLength // 2) + getKthElement(totalLength // 2 + 1)) / 2
