代码随想录算法训练营Day1 | 数组理论基础、704. 二分查找、27. 移除元素 | Python | 个人记录向

​数组理论基础

代码随想录：数组理论基础

一维数组

1. 数组下标都是从0开始的
2. 数组内存空间的地址是连续的

二维数组

实际的内存空间不一定连续。C++是连续的，JAVA不是。对于python来说，有两种实现方式：

1. 嵌套列表：子列表分散储存，且python的列表是动态对象，可以存储不同类别的元素，并动态调整大小。
2. numpy多维数组：连续内存块，但numpy的底层实现是C。

704. 二分查找

相关链接

代码随想录：二分查找
Leetcode：704. 二分查找

直接做题

了解过二分的思路，直接做，通过报错看到特殊情况，并对特殊情况进行处理，通过了。思路可行，但有2个问题：

1. 实际笔试无法看报错的例子。
2. 代码思路不规范，不够通用。

具体代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        size = len(nums)
        if size == 1:
            if nums[0] == target:
                return 0
            else:
                return -1
        left = 0
        right = size - 1
        while True:
            if left == (right - 1):
                if nums[left] == target:
                    return left
                elif nums[right] == target:
                    return right
                else:
                    return -1
            cur = (left + right) // 2
            if nums[cur] == target:
                return cur
            elif nums[cur] > target:
                right = cur
            else:
                left = cur

看文章

二分法前提条件

• 有序
• 无重复

复杂度

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

解法

根据2种区间定义，有相应解法。比自己探索的解法更规范。

左闭右闭

重点：

• 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, right = 0, len(nums) - 1  

        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  # 未找到目标值

左闭右开

（看懂上面的左闭右闭，就能都看懂）
重点：

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle

衍生题：35. 搜索插入位置

代码随想录：35. 搜索插入位置
Leetcode：35. 搜索插入位置
使用二分法求解，要注意针对问题处理边界，不能直接照搬。

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

代码随想录：34. 在排序数组中查找元素的第一个和最后一个位置
Leetcode：34. 在排序数组中查找元素的第一个和最后一个位置
我是先搜索任意一个target，然后再向左右分别找边界，不知道是不是复杂度高了？理论上如果全都是target，我从之间找边界，相当于O(n)？

代码随想录解法

重点思路：分别用二分法找左、右边界。使用二分法解决时，只有left > right，才算结束（而不是找到某个值就结束）。

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        def getRightBorder(nums:List[int], target:int) -> int:
            left, right = 0, len(nums)-1
            rightBoder = -2 # 记录一下rightBorder没有被赋值的情况
            while left <= right:
                middle = left + (right-left) // 2
                if nums[middle] > target:
                    right = middle - 1
                else: # 寻找右边界，nums[middle] == target的时候更新left
                    left = middle + 1
                    rightBoder = left
    
            return rightBoder
        
        def getLeftBorder(nums:List[int], target:int) -> int:
            left, right = 0, len(nums)-1 
            leftBoder = -2 # 记录一下leftBorder没有被赋值的情况
            while left <= right:
                middle = left + (right-left) // 2
                if nums[middle] >= target: #  寻找左边界，nums[middle] == target的时候更新right
                    right = middle - 1
                    leftBoder = right
                else:
                    left = middle + 1
            return leftBoder
        leftBoder = getLeftBorder(nums, target)
        rightBoder = getRightBorder(nums, target)
        # 情况一
        if leftBoder == -2 or rightBoder == -2: return [-1, -1]
        # 情况三
        if rightBoder -leftBoder >1: return [leftBoder + 1, rightBoder - 1]
        # 情况二
        return [-1, -1]

27. 移除元素

相关链接

代码随想录：移除元素
Leetcode：27. 移除元素

直接做题

快慢指针，思路接近，但错误，没找出bug。

看文章

暴力求解

两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组。
时间复杂度：O(n^2)
空间复杂度：O(1)

快慢指针

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

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

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

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

以往忽略的知识点小结

• 二分法：两种区间的含义
• 二分法的规范写法、边界处理
• 快慢指针的边界处理

个人体会

完成时间：基础内容3h + 拓展内容1h。
心得：之前是紧急备考，刷了约100道Leetcode和40%代码随想录，但感觉基础不牢。果然，第一天的题看似简单，也有思路，但自己做的时候，对具体实现思路还是不够熟悉，细节处理也差点意思。另一方面，也要在脑子里形成对计算复杂度的概念。需要依托这次训练营，沉下心夯实基础。

​