代码随想录算法训练营第一天 | 704.二分查找、27.移除元素

0704. 二分查找 Binary Search

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

提示：

• 你可以假设nums中的所有元素是不重复的。
• n将在[1, 10000]之间。
• nums的每个元素都将在[-9999, 9999]之间。

2. 解题思路

二分法的区间定义一般分为两种，左闭右闭[left, right]或者左闭右开[left, right)。

2.1. 左闭右闭[left, right]

• left = 0, right = len(nums) - 1。left为数组第一个元素，right为数组最后一个元素，[left, right]上的元素都能取到。
• if nums[middle] > target，right赋值为middle - 1，因为当前nums[middle] != target，继续在[left, middle - 1]中搜索。
• if nums[middle] < target，left赋值为middle + 1，因为当前nums[middle] != target，继续在[middle + 1, right]中搜索。
• middle取值：middle = (left + right) // 2。Python中//是floor函数，即向下取整。 middle = left + (right - left) // 2，为了防止整型溢出。
• 出界条件：while left <= right。 一旦退出循坏就意味着目标元素target不存在。出界条件为left = right + 1, 即[right, right + 1]，待查找空间没有元素存在，此时跳出循环返回-1。

具体代码实现：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
    left, right = 0, len(nums) - 1

    # 在[left, right]区间查找
    # 如果找到就返回
    while left <= right:
        middle = left + (right - left) // 2
        # middle = (left + right) // 2
        
        # nums[middle] == target, 返回middle
        if nums[middle] == target:
            return middle
        
            # middle > target -> [left, middle - 1]
        elif nums[middle] > target:
            right = middle - 1
        
            # middle < target -> [middle + 1, right]
        else:
            left = middle + 1

    # 出界就代表没有找到，返回 -1
    return -1

• 时间复杂度：O(logn)
• 空间复杂度：O(1)

2.2 左闭右开[left, right)

• left = 0, right = len(nums)。left为数组第一个元素，right不存在，[left, right)上的元素能取到right - 1。
• if nums[middle] > target，right赋值为middle，因为当前nums[middle] != target，继续在[left, middle）中搜索，即在下一个区间中不会比较nums[middle]。
• if nums[middle] < target，left赋值为middle + 1，因为当前nums[middle] != target，继续在[middle + 1, right]中搜索。
• middle取值：middle = (left + right) // 2。Python中//是floor函数，即向下取整。 middle = left + (right - left) // 2，为了防止整型溢出。
• 出界条件：while left < right。 一旦退出循坏就意味着目标元素target不存在。出界条件为left = right, 即（right, right）是无效空间，没有意义。循环内left可以取到right - 1，即数组最后一个元素

具体代码实现：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
    left, right = 0, len(nums)

    # 在[left, right)区间查找
    # 如果找到就返回
    while left < right:
        middle = left + (right - left) // 2
        # middle = (left + right) // 2
        
        # nums[middle] == target, 返回middle
        if nums[middle] == target:
            return middle
        
            # middle > target -> [left, middle)
        elif nums[middle] > target:
            right = middle
        
            # middle < target -> [middle + 1, right)
        else:
            left = middle + 1

    # 出界就代表没有找到，返回 -1
    return -1

• 时间复杂度：O(logn)
• 空间复杂度：O(1)

0027. 移除元素 Remove Element

Leetcode题目链接

1. 题目描述

给你一个数组nums和一个值val，你需要原地移除所有数值等于val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用O(1)额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明：

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

2. 解题思路

注意：数组array的元素在内存中的地址是连续的，不能删除，只能覆盖。

2.1 暴力解法：两层for循环

• 先定义i = 0，size = len(nums)，也可以用右指针l = len(nums)
• 第一层循环遍历数组，找到目标元素val之后，第二层for循环依次更新目标元素之后的数组
• 第二个for循环中更新数组时，设定j = [i + 1, size)，目标元素之后的数组整体向前移动，所以每i个元素被后一个i + 1个元素取代，即nums[j - 1] = nums[j]
• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

具体实现：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:

    i, size = 0, len(nums)

    while i < size:
            # 如果找到目标元素
            if nums[i] == val:
                # 依次更新后面数组
                for j in range(i + 1, size):
                    nums[j - 1] = nums[j]
                
                size -= 1 # 长度减1
                i -= 1
            i += 1
    
    return size

2.2 快慢指针

双指针法（快慢指针）：通过一个快指针和一个慢指针在一个for循环里完成两个循环的工作。

定义：

• 快指针：遍历数组，寻找新数组的元素，
• 慢指针：指向更新新数组下表的位置

具体算法实现：

• 初始化快指针fast和慢指针slow都指向0，即fast, slow = 0
• 快指针fast遍历数组，当num[fast]等于目标元素val时，即num[fast] == val时，慢指针slow不做更新；
• 如果num[fast] != val时，有两种情况
  • 前一个循环中，nums[fast] != val， 快指针fast继续向后遍历，此时fast和慢指针slow指针的在同一个位置，快指针指向的值nums[fast]赋值给慢指针nums[slow]，把slow向后移动一个位置（相当于没有操作）
  • 前一个循环中，nums[fast] == val，快指针fast继续向后遍历，此时fast在慢指针slow指针的后一个位置，快指针指向的值nums[fast]赋值给慢指针nums[slow]，把slow向后移动一个位置，即目标元素后一个位置的元素向前覆盖
• 最后返回新数组（没有目标元素数组）的长度，即返回慢指针slow

具体实现：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        fast, slow = 0, 0
        size = len(nums)

        # 出队条件为 fast = size， 遍历的最后一个元素为 nums[size-1]
        while fast < size: 
            if (nums[fast] != val):
                nums[slow] = nums[fast]
                slow += 1
            fast += 1

        return slow

• 时间复杂度：O(n)
• 空间复杂度：O(1)

今日收获

• 因为之前已经刷过今天的两题，所以写的很快，重点回顾了二分查找的左闭右闭和左闭右开，和数组快慢指针的应用。
• 继续向后刷代码随想录，目前刚刚结束哈希表，进入字符串
• 明天计划：加油继续学习，争取明天能字符串*3