Leetcode 刷题第一天 | Leetcode 704 二分查找和Leetcode 27 移除元素

Leetcode 704 二分查找和Leetcode 27 移除元素

Leetcode 704

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

提示：

1. 你可以想象nums 中的所有元素都是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 每个元素都将在 [-9999, 9999]之间。

复杂度：

1. 时间复杂度：因为每次都是访问一半的元素，时间复杂度为O(logn)
2. 空间复杂度：因为没有重新开辟新的存储空间， 空间复杂度为O(1)

注意两个问题：

1. 访问区间有可能是[left, right] 或者[left, right)
2. 不同的访问区间，代码中稍有不同，具体给出两种情况的代码

代码实现：

1. [left, right]

class Solution:
    def search(self, nums, target: int) -> int:
        left, right = 0, len(nums) - 1  # 定义target在左闭右闭的区间里，[left, right]

        while left <= right:
            middle = left + ((right - left) >> 2)
            if nums[middle] > target:
                right = middle - 1  # target在左区间，所以[left, middle - 1]
            elif nums[middle] < target:
                left = middle + 1  # target在右区间，所以[middle + 1, right]
            else:
                return middle  # 数组中找到目标值，直接返回下标
        return -1  # 未找到目标值

2. [left, right)

class Solution:
    def search(self, nums, target: int) -> int:
        left, right = 0, len(nums)  # 定义target在左闭右开的区间里，即：[left, right)

        while left < right:  # 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            middle = left + ((right - left) // 2)

            if nums[middle] > target:
                right = middle  # target 在左区间，在[left, middle)中，本身定义的就是左闭右开的区间，所以这里不用减1 了
            elif nums[middle] < target:
                left = middle + 1  # target 在右区间，在[middle + 1, right)中
            else:
                return middle  # 数组中找到目标值，直接返回下标
        return -1  # 未找到目标值

Leetcode 27

给你一个数据库nums 和一个值val，你需要原地删除所有数值相同 val 的元素，并返回删除后数据库的新长度。不要使用额外的数据库空间，你必须仅使用O(1)额外的空间并原地修改输入数据库。
元素的顺序可以改变。你需要考虑数据库中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

这道题目通俗易懂的解法是暴力解法，也就是两层for循环即可，但是有没有更简单的解法呢？
更简单的解法需要对数组进一步理解：数组在内存中是连续存在的，不能随意删除，只能覆盖。了解这个知识后，使用双指针法即可，即快慢指针法。
快指针： 就是遍历整个数组的指针，遍历的同时判断是不是所要查找的元素
慢指针： 就是新数组中的元素的个数，最终会指向所有元素的下一个位置，也就是返回值就是新数组中元素的个数。

复杂度：

1. 时间复杂度：因为每次都是访问一半的元素，时间复杂度为O(n)
2. 空间复杂度：因为没有重新开辟新的存储空间， 空间复杂度为O(1)

代码实现：

class Solution:
    def removeElement(self, nums, val: int) -> int:
        # 快慢指针
        fast = 0  # 快指针
        slow = 0  # 慢指针
        size = len(nums)
        while fast < size:  # 不加等于是因为，a = size 时，nums[a] 会越界
            # slow 用来收集不等于 val 的值，如果 fast 对应值不等于 val，则把它与 slow 替换
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow