随想录算法训练营第一天| 704. 二分查找、27. 移除元素标题、35&34补充

最新推荐文章于 2024-06-07 19:11:00 发布

Echo0058

最新推荐文章于 2024-06-07 19:11:00 发布

阅读量663

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/qq_45139353/article/details/127274997

版权

一、刷题：

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]