LeetCode算法刷题——二分查找+双指针
LeetCode算法刷题by Python——二分查找 + 双指针
- 一、二分查找
-
- 1. 二分查找
- 2. 第一个错误的版本
- 3. 搜索插入位置
- 二、双指针
-
- 1. 有序数组的平方
- 2. 旋转数组
- 3. 移动零
- 4. 两数之和
- 5. 反转字符串
- 6. 反转字符串中的单词
- 7. 链表的中间结点
- 8. 删除链表的倒数第N个结点
虽然lz目前还是一名实验室搬砖硕士，但是怀揣着成为一名优秀程序猿的宏图大志，本着笨鸟先飞的理念，我决定开启我的LeetCode之旅 (撒花★,°:.☆(￣▽￣)/$:.°★ 。)
理性的衡量了自己的水平，经过一番甄选以后，我决定从LeetCode算法入门专栏开始。虽然难度不高，但是有助于自己熟悉LeetCode刷题的基本操作，并且掌握一些题型的固定套路，不失为一个入门良策~
那么话不多说，我们顺着算法入门专栏的题型设置，开启我们的旅程。
一、二分查找
1. 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
这一题暴力方法非常简单，一次遍历就解决问题，相信也是大家第一反应就能想到的方法。
class Solution:
def search(self, nums: List[int], target: int) -> int:
for i in range(len(nums)):
if nums[i] == target:
return i
return -1
但是这样的暴力做法得到的时间复杂度是O(N)，如果想要得到O(logN)的算法，就需要用到今天的主题之一——二分查找了。所谓二分查找，就是在顺序确定的数据中不断使用二分法来确定查找方向，从而快速找到target。
class Solution:
def search(self, nums: List[int], target: int) -> int:
l, r = 0, len(nums) - 1 # 获取列表左右坐标
while l <= r:
mid = l + (r - l) // 2 # 获取列表中间坐标
if nums[mid] == target:
return mid
elif nums[mid] < target: # 当列表中间值小于target时，说明可能的结果落在mid的右半区，此时我们需要将查找范围放在右半区
l = mid + 1
else: # 同理，当列表中间值大于target时，说明可能的结果落在mid的左半区，此时我们需要将查找范围放在左半区
r = mid - 1
return -1
2. 第一个错误的版本
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例 1：
输入：n = 5, bad = 4
输出：4
解释： 调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。示例2：
输入：n = 1, bad = 1
输出：1
提示：
- 1 <= bad <= n <= 2 31 2^{31} 231 - 1
因为这道题给了提示，说明测试用例里有很大的bad值，因此暴力方法大概率会超出时间限制，我们直接使用二分查找方法。
# The isBadVersion API is already defined for you.
# @param version, an integer
# @return an integer
# def isBadVersion(version):
class Solution:
def firstBadVersion(self, n):
"""
:type n: int
:rtype: int
"""
l, r = 1, n
while l < r: # 因为mid值可能就是答案，而这道题不像第一道一样是target精确定位，所以采用这个模板
mid = l + (r - l) // 2
if isBadVersion(mid) == True:
r = mid
else:
l = mid + 1
return l
3. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
看到O(logN)，不用想那肯定就是二分查找了，大家也要养成这个条件反射。
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
if len(nums) == 0:
return 0
l, r = 0, len(nums) - 1
while l <= r:
mid = l + (r - l) // 2
if nums[mid] == target:
return mid
elif nums[mid] > target:
r = mid - 1
else:
l = mid + 1
return l
二、双指针
1. 有序数组的平方
给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
由于我们使用python做题，那么一定能想到sorted函数，顺理成章直接输出。
class Solution:
def sortedSquares(self, nums: List[int]) -> List[int]:
return sorted(num **2 for num in nums)
当然说一下我的逻辑：非递减的数组nums是有负数的，那么平方后必然存在一个先递减再递增的过程，那么只需要在递减过程中不断将nums[l]平方与nums[r]平方作比较，将答案列表的右端填充完成；在递增过程的时候直接将剩下的数依次填入列表左端就可以了。
class Solution:
def sortedSquares(self, nums: List[int]) -> List[int]:
n = len(nums)
ans = [0] * n
l, r, p = 0, n - 1, n - 1
while l < r:
if nums[l] ** 2 >= nums[l + 1] ** 2 and nums[r] ** 2 >= nums[l] ** 2:
ans[p] = nums[r] ** 2
r -= 1
elif nums[l] ** 2 >= nums[l + 1] ** 2 and nums[r] ** 2 < nums[l] ** 2:
ans[p] = nums[l] ** 2
l += 1
elif nums[l] ** 2 < nums[l + 1] ** 2:
ans[p] = nums[r] ** 2
r -= 1
p -= 1
ans[0] = nums[l] ** 2
return ans
上面的方法逻辑没问题，但是太绕了，其实可以直接排序的，精简如下：
class Solution:
def sortedSquares(self, nums: List[int]) -> List[int]:
n = len(nums)
ans = [0] * n
l, r, p = 0, n - 1, n - 1
while l <= r:
if nums[l] ** 2 < nums[r] ** 2:
ans[p] = nums[r] ** 2
r -= 1
else:
ans[p] = nums[l] ** 2
l += 1
p -= 1
return ans
2. 旋转数组
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
进阶：
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？
示例 1:
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:
输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
这道题我第一反应想到的是切片，如果把挪到前面的几个数字从nums中切出来，与之前位于前面的几个数字的切片concat，不就是旋转后的数组吗？
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
n = len(nums)
k %= n # k可能会大于n，导致溢出，所以做取余操作
list1 = nums[-k: n] # 挪到前面的几个数字组成的列表切片
list2 = nums[0: -k] # 未被移动的几个数字组成的列表切片
ans = list1 + list2
for i in range(n):
nums[i] = ans[i]
可以再简洁一点。
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
k %= len(nums)
nums[:] = nums[-k:] + nums[:-k]
或者直接一点，将nums里的数字直接填入新数组中。
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
n = len(nums)
ans = [0] * n
for i in range(n):
ans[(i + k) % n] = nums[i]
for i in range(n):
nums[i] = ans[i]
但是以上方法均不满足空间复杂度为O(1)的条件，因为即使没有额外的数组，切片也会产生临时变量，因此我们老老实实使用指针再做一次。
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
n = len(nums)
k = k % n
def reverse(nums: List[int]):
l, r = 0, len(nums) - 1
while l < r:
nums[l], nums[r] = nums[r], nums[l]
l += 1
r -= 1
return nums
# 三次翻转
nums = reverse(nums)
nums[:k] = reverse(nums[:k])
nums[k:] = reverse(nums[k:])
3. 移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明: 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。
不多说了，在原始数组上面遍历交换就行。
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
n = len(nums)
l, r = 0, 0
while r < n:
if nums[r] != 0:
nums[l], nums[r] = nums[r], nums[l]
l += 1
r += 1
4. 两数之和
给定一个已按照 非递减顺序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。
你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。
示例 1：
输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9。因此 index1 = 1, index2 = 2 。
示例 2：
输入：numbers = [2,3,4], target = 6
输出：[1,3]
示例 3：
输入：numbers = [-1,0], target = -1
输出：[1,2]
这道题一定要注意numbers下标从1开始计数这个条件，所以返回的是[l + 1, r + 1]。
class Solution:
def twoSum(self, numbers: List[int], target: int) -> List[int]:
n = len(numbers)
l, r = 0, n - 1
while l < r:
if numbers[l] + numbers[r] == target:
return [l + 1, r + 1]
elif numbers[l] + numbers[r] < target:
l += 1
else:
r -= 1
return [l + 1, r + 1]
5. 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
太简单了，不解释。
class Solution:
def reverseString(self, s: List[str]) -> None:
"""
Do not return anything, modify s in-place instead.
"""
l, r = 0, len(s) - 1
while l < r:
s[l], s[r] = s[r], s[l]
l += 1
r -= 1
6. 反转字符串中的单词
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
示例：
输入：“Let’s take LeetCode contest”
输出：“s’teL ekat edoCteeL tsetnoc”
比上一题多处理两步就行。首先需要按空格把单词分开，反转后组合起来就可以了。
class Solution:
def reverseWords(self, s: str) -> str:
new_s = ""
for word in s.split():
word = list(word)
l, r = 0, len(word) - 1
while l < r:
word[l], word[r] = word[r], word[l] # str型不能做这样的操作
l += 1
r -= 1
new_s += "".join(word) # 将转为单字符的单词重新组合成字符串
new_s += " "
return new_s[:len(new_s) - 1] # 句子末尾多了一个空格，所以把前面切片
7. 链表的中间结点
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
示例 1：
输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
示例 2：
输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。
这一题如果利用双指针的思想，假设两个指针同时出发，当一个指针遍历完链表的时候，另一个指针到达链表一半的位置，那么前一个指针的遍历速度应该是后一个的二倍，这也就是快慢指针法。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def middleNode(self, head: ListNode) -> ListNode:
s = f = head
while f and f.next:
f = f.next.next
s = s.next
return s
8. 删除链表的倒数第N个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
这个题目依然沿用上一题的快慢指针思想，只需要让快指针走完链表的时候慢指针停在需要删除的结点之前位置，然后让它下一位置直接指向删除结点的下一位置即可。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(0, head) # 定义哑节点是常规操作，dummy.next指向head node
s = dummy
f = head
for i in range(n):
f = f.next
while f:
f = f.next
s = s.next
s.next = s.next.next
return dummy.next
（未来会更新更多相关题目，敬请关注。新手看到这里就可以啦。）
来源：力扣（LeetCode）
链接：https://leetcode-cn.com