目录
1. 704
2. 27
1. 35
2. 34
一、刷题:
1. 704二分查找
leetcode link:力扣
题目描述;给定一个 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
提示:nums中元素不重复
(有重复元素,二分查找返回的元素下标可能不唯一)
- 线性搜索(没看讲解前自己的做法)
# 线性搜索
class Solution:
def search(self, nums: List[int], target: int) -> int:
for i in range(len(nums)):
# print(i, nums[i])
if nums[i] == target:
return i
return -1
# 偷懒做法——不建议
class Solution:
def search(self, nums: List[int], target: int) -> int:
if target in nums:
return nums.index(target)
else:
return -1
重点:二分法涉及的边界条件
遵循循环不变量规则:在二分查找的过程中,保持不变量,就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作
两种情况:左闭右闭即[left, right],或者左闭右开即[left, right)
1.1 法一:左闭右闭区间
- while (left <= right) 要使用 <= ,因为left == right是有意义的,所以使用 <=
- if (nums[middle] > target) right 要赋值为 middle - 1,因为当前这个nums[middle]一定不是target,那么接下来要查找的左区间结束下标位置就是 middle - 1
class Solution:
def search(self, nums: List[int], target: int) -> int:
left = 0 # 左闭
right = len(nums)-1 # 右闭
while left <= right: # left==right,i.e.left==right==middle
middle = (left + right) // 2
if nums[middle] > target: # target在左区间
right = middle - 1
elif nums[middle] < target: # target在右区间
left = middle + 1
else:
return middle
return -1
# 另一种写法
class Solution:
def search(self, nums: List[int], target: int) -> int:
if nums is None or len(nums)==0:
return -1
l=0
r=len(nums)-1
while (l<=r):
m = round(l+(r-l)/2)
if nums[m] == target:
return m
elif nums[m] > target:
r=m-1
else:
l=m+1
return -1
1.2 法二 ——[left, right)
- while (left < right),这里使用 < ,因为left == right在区间[left, right)是没有意义的
- if (nums[middle] > target) right 更新为 middle,因为当前nums[middle]不等于target,去左区间继续寻找,而寻找区间是左闭右开区间,此时右端点为middle,且此处为开,所以right更新为middle,即:下一个查询区间不会去比较nums[middle]
class Solution:
def search(self, nums: List[int], target: int) -> int:
left = 0 # 左闭
right = len(nums) # 右开
while left < right:
middle = (left + right) // 2
if nums[middle] > target: # target在左区间
right = middle
elif nums[middle] < target: # target在右区间
left = middle + 1
else:
return middle
return -1
2. 27移除元素
链接:https://leetcode.cn/problems/remove-element
题目描述:给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
思路:数组的元素在内存地址中是连续的,不能单独删除数组中的某个元素,只能覆盖。
2.1 暴力解法:两层for循环,一个for循环遍历数组元素 ,第二个for循环更新数组。
时间复杂度:O(n^2) 空间复杂度:O(1)
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
size = len(nums)
i = 0
# i<size也是因为数组一直在更新
while i < size: # 注意这里循环不能用for,因为当i=i-1后,并不影响for循环的i值,也就是i -= 1这一步白操作了
if nums[i] == val:
for j in range(i+1, len(nums)):
nums[j-1] = nums[j]
i -= 1 # 相当于覆盖了一位,下个循环下标不变
size -= 1
# print(i, nums)
i += 1
return size
2.2 双指针法:
(快慢指针法): 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
- 快指针:寻找新数组的元素 ,新数组就是不含有目标元素的数组
- 慢指针:指向更新 新数组下标的位置
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
slow_index = 0
for fast_index in range(len(nums)):
# print(slow_index, fast_index, nums)
if nums[fast_index] != val:
nums[slow_index] = nums[fast_index]
slow_index += 1
return slow_index
if nums[fast_index] != val:
nums[slow_index] = nums[fast_index]
slow_index += 1
这一步很关键
注意这些实现方法并没有改变元素的相对位置!
# 相向双指针方法,基于元素顺序可以改变的题目描述改变了元素相对位置,确保了移动最少元素
# 时间复杂度:O(n)
# 空间复杂度:O(1)
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
if nums is None or len(nums)==0:
return 0
l=0
r=len(nums)-1
while l<r:
while(l<r and nums[l]!=val):
l+=1
while(l<r and nums[r]==val):
r-=1
nums[l], nums[r]=nums[r], nums[l]
print(nums)
if nums[l]==val:
return l
else:
return l+1
二、数组理论基础:
1. 数组在内存中的存储方式:数组是存放在连续内存空间上的相同类型数据的集合
数组可以通过下标索引获取到对应的数据,下标从0开始,内存空间的地址是连续的。
优点:方便读取
缺点:因为数组的在内存空间的地址是连续的,所以我们在删除或增添元素的时候,难免要移动其他元素的地址。
C++要注意vector 和 array的区别,vector的底层实现是array,严格来讲vector是容器,不是数组。
数组的元素是不能删的,只能覆盖。——没理解
二维数组的内存地址,以C++为例是连续的;Java没有指针,同时也不对程序员暴露元素地址,寻址操作完全交给虚拟机。
评价:内容偏面试,想知道具体知识点的可能需要查阅课本。
三、拓展题
35. 搜索插入位置
给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
法一:该方法不符合时间复杂度
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
if target in nums:
return nums.index(target)
else:
for i in range(len(nums)):
if nums[i] >= target:
return i
if target > nums[len(nums)-1]:
return len(nums)
略显繁琐,有几步没必要,修改后;
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
for i in range(len(nums)):
if nums[i] >= target:
return i
return len(nums)
时间复杂度的要求是O(logn),所以改用二分法(当题里给出的数组是有序数组,且无重复元素,都可以思考是否可以使用二分法)
根据704:
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
left, right = 0, len(nums) - 1
while left <= right:
middle = (left + right) // 2
if nums[middle] > target:
right = middle - 1
elif nums[middle] < target:
left = middle + 1
else:
return middle
# 需要注意return right+1 是为什么
# 如果target比数组所有数都小,则放在nums[0]处,此时left==right+1==0
# 如果target比数组所有数都大,则放在nums[len(nuns)]处,此时left==right+1==8
return right + 1
34. 在排序数组中查找元素的第一个和最后一个位置
如果数组中不存在目标值 target,返回 [-1, -1]。
进阶:你可以设计并实现时间复杂度为 $O(\log n)$ 的算法解决此问题吗?
示例 1:
- 输入:nums = [5,7,7,8,8,10], target = 8
- 输出:[3,4]
示例 2:
- 输入:nums = [5,7,7,8,8,10], target = 6
- 输出:[-1,-1]
示例 3:
- 输入:nums = [], target = 0
- 输出:[-1,-1]
class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
if nums == []:
return [-1, -1]
def get_right_border(nums: List[int], target: int) -> int:
l = 0
r = len(nums)-1
right_border = -2 # 记录right_border未赋值的情况
while l <= r:
m = (l + r) // 2
if nums[m] > target:
r = m - 1
else: # nums[m] == target
l = m + 1
right_border = l
return right_border
def get_left_border(nums: List[int], target: int) -> int:
l = 0
r = len(nums)-1
left_border = -2 # 记录left_border未赋值的情况
while l <= r:
m = (l + r) // 2
if nums[m] < target:
l = m + 1
else: # nums[m] == target
r = m - 1
left_border = r
return left_border
left_border = get_left_border(nums, target)
right_border = get_right_border(nums, target)
if left_border == -2 or right_border == -2:
return [-1, -1]
elif right_border - left_border > 1:
return [left_border+1, right_border-1]
else:
return [-1, -1]