代码随想录训练营 Day1打卡 704. 二分查找，27. 移除元素

那一抹阳光多灿烂

已于 2024-07-17 10:09:31 修改

阅读量739

点赞数 21

分类专栏：力扣文章标签： python 力扣

于 2024-07-17 10:04:41 首次发布

本文链接：https://blog.csdn.net/qq_42952637/article/details/140483747

版权

力扣专栏收录该内容

46 篇文章 0 订阅

订阅专栏

代码随想录训练营 Day1打卡数组part01

一、数组理论基础

在Python中，数组通常是指列表（list），尽管还有其他形式的数组，如元组（tuple）和NumPy库中的数组。这里我们主要讨论Python的列表，因为它是最常用的数组形式之一。
Python的列表是可变的数据结构，能够存储不同类型的元素，如整数、字符串、对象等。列表是动态数组，其大小和内容可以随时改变。

# 创建列表
my_list = [1, 2, 3, 4]
# 访问元素:
print(my_list[0])  # 输出 1
# 添加元素:
my_list.append(5)  # 现在列表变为 [1, 2, 3, 4, 5]
# 删除元素:
del my_list[2]  # 删除索引为2的元素，列表变为 [1, 2, 4, 5]

数组的内存空间地址

在Python中，列表存储的是对其元素的引用，而不是数据本身。这意味着列表中的每个元素都可以看作是指向内存中对象的指针。
内存地址 : 使用id()函数可以获取对象的内存地址，这个地址表示Python对象在内存中的位置。

a = 1
print(id(a))  # 输出变量a的内存地址
# 对于列表来说：
my_list = [1, 2, 3]
print(id(my_list))  # 输出整个列表的内存地址
print(id(my_list[0]))  # 输出列表中第一个元素的内存地址

数组与内存

由于Python的动态性，列表的内存管理相对复杂。当列表增长时，Python可能会重新分配整个列表的内存以适应更多的元素。这是因为列表可能需要更多连续的内存空间。

列表的内存扩展

Python的列表实现了一个动态数组。当元素添加到列表中，且现有的内存空间不足以存储更多元素时，Python会分配一块更大的内存块来存储列表的元素，并将旧元素复制到新的内存块中。
这种动态内存管理方式使得Python列表在处理可变大小的数据集时非常灵活，但也可能导致内存使用不如静态类型语言（如C或C++中的数组）高效。
Python的内存管理和垃圾收集机制确保了不再使用的对象会被自动回收，这有助于减少内存泄漏和其他内存相关的问题。

二、力扣704. 二分查找

给定一个 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

算法思路

初始化指针：设立两个指针，left 和 right，分别指向数组的起始位置（下标为0）和终止位置（下标为n-1，其中n是数组长度）。这样就定义了一个搜索区间[left, right)或[left, right]。

循环条件：当left <= right时（对于左闭右闭区间），或left < right时（对于左闭右开区间），进入循环执行查找过程。这意味着搜索区间非空。

计算中间点：为了避免大数导致的整型溢出，通常使用(left + right) // 2 或 left + (right - left) // 2 来安全地获取中间索引middle。

比较并调整指针：

如果nums[middle] == target，找到了目标值，直接返回middle作为其索引。
如果nums[middle] > target，说明目标值在左半部分（对于升序数组），因此将搜索区间调整为[left, middle - 1]（左闭右闭）或[left, middle)（左闭右开）。
如果nums[middle] < target，说明目标值在右半部分，将搜索区间调整为[middle + 1, right]（左闭右闭）或[middle + 1, right)（左闭右开）。
循环结束处理：如果循环结束后还没有找到目标值，表明目标值不在数组中，返回-1。

版本一左闭右闭区间

class Solution:
    def search(self, nums: List[int], 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  # 未找到目标值

版本二左闭右开区间

class Solution:
    def search(self, nums: List[int], 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)中
            elif nums[middle] < target:
                left = middle + 1  # target 在右区间，在[middle + 1, right)中
            else:
                return middle  # 数组中找到目标值，直接返回下标
        return -1  # 未找到目标值

力扣题目链接
 题目文章讲解
 题目视频讲解

三、移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。
假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。
示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,,]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
示例 2：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,,,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

版本一快慢指针法

定义快慢指针

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

class Solution:
    def removeElement(self, nums: List[int], 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

（快慢指针法）是一种非常高效的解决方案，时间复杂度为O(n)，它只遍历数组一次。快指针用于遍历整个数组，慢指针则用来记录新的数组的有效长度。当遇到不等于val的元素时，就将其移到慢指针的位置，以此达到原地移除的效果。这种方法空间复杂度为O(1)，是这个问题的推荐解法。

版本二暴力法

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i, l = 0, len(nums)
        while i < l:
            if nums[i] == val: # 找到等于目标值的节点
                for j in range(i+1, l): # 移除该元素，并将后面元素向前平移
                    nums[j - 1] = nums[j]
                l -= 1
                i -= 1
            i += 1
        return l

（暴力法）也是遍历数组，但其内部包含了一个循环用于元素的移动，导致其平均时间复杂度上升至O(n^2)，在数组中存在大量目标值时性能较差。虽然这个方法直观展示了如何直接移除元素并前移数组内容，但效率低下，不是最优解。

版本三相向双指针法

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        n = len(nums)
        left, right  = 0, n - 1
        while left <= right:
            while left <= right and nums[left] != val:
                left += 1
            while left <= right and nums[right] == val:
                right -= 1
            if left < right:
                nums[left] = nums[right]
                left += 1
                right -= 1
        return left

（相向双指针法）采用了双指针技巧，左指针left从头开始，右指针right从尾部开始。当nums[left]不等于val时，直接递增left；当nums[right]等于val时，递减right。
这样做的目的是尽量减少交换操作，直到左右指针相遇，此时left即为新数组的有效长度。这种方法同样保持了O(n)的时间复杂度和O(1)的空间复杂度，且代码实现相对简洁高效。

力扣题目链接
 题目文章讲解
 题目视频讲解