Leetcode刷题记录（代码随想录day01）

Day 01

每天两到三道题，使用语言python，有时间会把类似题目做一下

1. 二分法

当题目强调有序数组，和数组中无重复元素时，就可以考虑二分查找了。

二分查找会遇到的问题主要是判定区间。区间定义一般分为左闭右闭[left, right]和左闭右开即[left, right)，在查找过程中一定要注意到底有没有+1 / 循环条件用<=还是用<。

704. 二分查找

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

解：二分查找，取数组中间值，注意判定区间，不带等于号时，值要+1。之前做错了，是没有注意到将result赋值的位置，注意要找到位置再赋值，不要在判断target位置时就改变result。

class Solution:
    # 自己写的
    def search(self, nums: List[int], target: int) -> int:
        tmin = 0
        tmax = len(nums)-1
        result = -1
        if nums[tmin] <= target & target <= nums[tmax]:
            while(tmin != tmax):
                t = int((tmax+tmin)/2)
                if target <= nums[t]:
                    tmax = t
                elif target > nums[t]:
                    tmin = t+1
            if target == nums[tmin]:
                result = tmin
            else:
                result = -1
        else:
            result = -1
        return result
    
    # 简短一点的，将问题转化为查找target=[tmin,tmax]的左右区间
    def search(self, nums: List[int], target: int) -> int:
        tmin = 0
        tmax = len(nums)-1
        while(tmin<=tmax):
            t = int((tmax+tmin)/2)
            if nums[t] > target:
                tmax = t-1
            elif nums[t] < target:
                tmin = t+1
            else:
                result = t
                return result
        result = -1
        return result

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

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

解：先找左边界，再找右边界，思路更清楚

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        if len(nums)==0:
            return [-1, -1]
        tmin = 0
        tmax = len(nums)-1
        result = [-1, -1]
        if nums[tmin] <= target & target <= nums[tmax]:
            while(tmin<=tmax):
                t = int((tmax+tmin)/2)
                if nums[t] >= target:
                    tmax = t-1
                elif nums[t] < target:
                    tmin = t+1
            if target == nums[tmin]:
                temp = tmin
            else:
                temp = -1
            tmax = len(nums)-1
            while(tmin<=tmax):
                t = int((tmax+tmin)/2)
                if nums[t] > target:
                    tmax = t-1
                elif nums[t] <= target:
                    tmin = t+1
            if target == nums[tmax]:
                result = [temp, tmax]
            else:
                result = [-1, -1]
        return result

相关题目

35.搜索插入位置(opens new window)
69.x 的平方根
367.有效的完全平方数

2. 移除元素

主要是了解双指针法，当题目提到时间复杂度：O(n)，或原地等时，就可以考虑双指针法。通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
慢指针：指向更新后新数组下标的位置
删除过程如下：

27. 移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

解：
暴力解法：最简单的方法就是两层循环，一层查找，一层删除

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

（注：力扣已经设定好nums是引用了，所以只需传递size即可）

暴力破解的时间复杂度是O(n^2)，双指针法的时间复杂度为O(n)，这两种方法空间复杂度都是O(1)

双指针法：快慢指针法，一个指针负责循环读取数组，一个指针负责指向下一个元素位置

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        size = len(nums)
        fast = 0
        slow = 0
        while fast < size:
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow

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

给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的相对顺序应该保持一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。将最终结果插入 nums 的前 k 个位置后返回 k 。不要使用额外的空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

解：同上题，注意上题是拿快指针与给定值相比，而这题没有对应给定数据，若用nums[fast]和nums[fast+1]/nums[fast-1]相比，会涉及到数组读数问题，所以用nums[slow]会比较合适。同时注意slow+1的位置，这两个题不太一样

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        size = len(nums)
        fast = 0
        slow = 0
        while fast < size:
            if nums[fast] != nums[slow]:
                slow += 1
                nums[slow] = nums[fast]
            fast += 1
        if size == 0:
            return 0
        if size == 1:
            return 1
        return slow+1

相关题目

283.移动零
844.比较含退格的字符串
977.有序数组的平方