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

数组理论基础

数组是存放在连续内存空间上的相同类型数据的集合。

因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，需要移动其他元素的地址。

那么二维数组在内存的空间地址是连续的么？不同编程语言的内存管理是不一样的，以C++为例，在C++中二维数组是连续分布的。

704. 二分查找

看题解之前

二分查找，前提是有序数组。数组元素重复的话返回值不唯一

区间的定义不要改变，根据区间定义确定边界条件

使用左闭右闭

1. while left <= right 左闭右闭的情况下，left==right是有效的
2. if target < nums[mid]: right = mid - 1 此时mid已经不满足条件，在左闭右闭的情况下，需要移动到有效区间上
3. if target > nums[mid]: left = mid + 1
4. 初始化 right = len(nums) - 1

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # 左闭右闭区间
        left = 0
        right = len(nums) - 1
        while left <= right:
            mid = left + (right - left) // 2
            if target < nums[mid]:
                right = mid - 1
            elif target > nums[mid]:
                left = mid + 1
            else:
                return mid
        return -1

使用左闭右开

1. while left < right 左闭右开的情况下，left==right是没有意义的
2. if target < nums[mid]: right = mid 此时mid不满足条件，在左闭右开的情况下，right可以移动到mid上
3. if target > nums[mid]: left = mid + 1 左区间一直是有效的
4. 初始化 right = len(nums)

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # 左闭右开区间
        left = 0
        right = len(nums)
        while left < right:
            mid = left + (right - left) // 2
            if target < nums[mid]:
                right = mid
            elif target > nums[mid]:
                left = mid + 1
            else:
                return mid
        return -1

看题解之后

区间的定义就是不变量。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。

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

35.搜索插入位置

有序数组且数组元素不重复，可以使用二分查找。只有最后返回的时候不一样，返回left的值

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        # 左闭右闭区间
        left = 0
        right = len(nums) - 1
        while left <= right:
            mid = left + (right - left) // 2
            if target < nums[mid]:
                right = mid - 1
            elif target > nums[mid]:
                left = mid + 1
            else:
                return mid
        return left



class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        # 左闭右开区间
        left = 0
        right = len(nums)
        while left < right:
            mid = left + (right - left) // 2
            if target < nums[mid]:
                right = mid
            elif target > nums[mid]:
                left = mid + 1
            else:
                return mid
        return left

34. 在排序数组中查找元素的第一个和最后一个位置

有序数组，但是数组元素不唯一，找到元素的第一个和最后一个位置。有序数组的话就可以使用二分查找了，重复元素会让题目变得复杂

直接看题解，先寻找左右边界，然后根据寻找到的左右边界进行判定

情况一：

target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}

此时代码中在寻找左右边界时有一个边界为初始值

情况二：

target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}

此时代码left_border = 0, right_border = 1

情况三：

target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}

此时代码left_border = 0, right_border = 2

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        # 寻找左边界
        def getLeftBorder(nums, target):
            # 左闭右闭区间
            left = 0
            right = len(nums) - 1
            left_border = -2
            while left <= right:
                mid = left + (right - left) // 2
                if target <= nums[mid]:
                    right = mid - 1
                    left_border = right
                else:
                    left = mid + 1
            return left_border

        def getRightBorder(nums, target):
            # 左闭右闭区间
            left = 0
            right = len(nums) - 1
            right_border = -2
            while left <= right:
                mid = left + (right - left) // 2
                if target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
                    right_border = left
            return right_border

        left_border = getLeftBorder(nums, target)
        right_border = getRightBorder(nums, target)
        # 情况一
        if left_border == -2 or right_border == -2:
            return [-1, -1]
        # 情况三
        if right_border - left_border > 1:
            return [left_border+1, right_border-1]
        # 情况二
        return [-1, -1]

69.x 的平方根

思路：使用二分查找的思路，left=0，right=x，得到mid，mid的平方和x进行比较。主要是思考返回值

class Solution:
    def mySqrt(self, x: int) -> int:
        left = 0
        right = x
        while left <= right:
            mid = left + (right - left) // 2
            if mid * mid > x:
                right = mid - 1
            elif mid * mid < x:
                left = mid + 1
            else:
                return mid
        return right

看了其中一个题解，这种提前确定答案的也比较好理解

• mid * mid > x时，mid肯定不能满足条件，r=mid-1
• mid * mid <= x时，mid有可能满足条件

class Solution:
    def mySqrt(self, x: int) -> int:
        l, r, ans = 0, x, -1
        while l <= r:
            mid = (l + r) // 2
            if mid * mid <= x:
                ans = mid
                l = mid + 1
            else:
                r = mid - 1
        return ans

367.有效的完全平方数

这个题目和平方根实质是一样的，更简单一点，都不用考虑返回值

class Solution:
    def isPerfectSquare(self, num: int) -> bool:
        left = 1
        right = num
        while left <= right:
            mid = left + (right - left) // 2
            if mid * mid == num:
                return True
            elif mid * mid < num:
                left = mid + 1
            else:
                right = mid - 1
        return False

27. 移除元素

暴力法：第一层循环遍历每个元素，在遇到val时，循环后移所有元素

双指针法：快指针对应循环遍历，慢指针对应排除掉val元素后的序列

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        slow = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[slow] = nums[i]
                slow += 1
        return slow

26.删除排序数组中的重复项

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        # 使用快慢指针，快指针进行循环遍历，慢指针对应删除重复元素后的序列
        slow = 1
        for i in range(1, len(nums)):
            if nums[i] != nums[slow-1]:
                nums[slow] = nums[i]
                slow += 1
        return slow

283.移动零

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # 和移除元素一个意思，val==0的特殊情况
        slow = 0
        for i in range(len(nums)):
            if nums[i] != 0:
                nums[slow] = nums[i]
                slow += 1
        # 对剩下的元素赋值为0
        for i in range(slow, len(nums)):
            nums[i] = 0

844.比较含退格的字符串

可以使用栈的思路；也可以从字符串后面开始比较，定义常量skip记录当前待删除的字符的数量

977.有序数组的平方

指针指向两端，数值大的放在结果数组结尾

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        res = [0] * len(nums)
        i = 0
        j = len(nums) - 1
        index = j
        while i <= j:
            if nums[i] * nums[i] <= nums[j] * nums[j]:
                res[index] = nums[j] * nums[j]
                j -= 1
            else:
                res[index] = nums[i] * nums[i]
                i += 1
            index -= 1
        return res