代码随想录 day 1 （二刷）704. 二分查找 27. 移除元素 209.长度最小的子数组

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

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

code python 1 []

from typing import List
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        """
        条件： nums 有序；
        # [], [)
        """
        left, right = 0, len(nums)-1
        while left <= right:  # 区间 与限定一致
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                left = mid + 1
            else:
                right = mid - 1
        return -1

code python 2 [)

from typing import List
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        """
        条件： nums 有序；
        # [)
        """
        left, right = 0, len(nums)
        while left < right:  # 区间 与限定一致
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                left = mid + 1
            else:
                right = mid
        return -1

27. 移除元素

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

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

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

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

你不需要考虑数组中超出新长度后面的元素。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

code python 1 交换

from typing import List
class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        left, right = 0, len(nums)-1   # left 记录移除后数组的新长度
        while left <= right:
            if nums[left] != val:
                left += 1
            else:
                # nums[left], nums[right] = nums[right], nums[left]
                nums[left] = nums[right]
                right -= 1
        return left

code python 2

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

code python 3

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        left = 0   # left 记录移除后数组的新长度
        for right in range(len(nums)):
            if nums[right] != val:
                nums[left] = nums[right]
                left += 1
        return left

977.有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

请你设计时间复杂度为 O(n) 的算法解决本问题

code python 1 for

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        n = len(nums)
        res = [0 for i in range(n)]
        left, right = 0, n - 1
        nums = [v * v for v in nums]
        for i in range(n-1, -1, -1):
            if nums[left] > nums[right]:
                res[i]=nums[left]
                left += 1
            else:
                res[i] = nums[right]
                right -= 1
        return res

code python 2 while

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

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
提示：

1 <= target <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
#算法公开课

code python 1

class Solution:
    # sublist = target and 返回其长度
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left, right = 0, 0
        n = len(nums)
        sum1 = 0
        minlens = n + 1
        while left <= right and right < n:
            sum1 += nums[right]   # 往前移动

            while sum1 >= target and left <= right:  # 满足条件
                if minlens > right - left + 1:
                    minlens = right - left + 1
                sum1 -= nums[left]
                left += 1
            right += 1
        return minlens if minlens != n + 1 else 0

code python 2

class Solution:
    # sublist = target and 返回其长度
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left, right = 0, 0
        n = len(nums)
        sum1 = 0
        minlens = n + 1
        for right in range(n):
            sum1 += nums[right]
            while sum1 >= target:  # 满足条件
                if minlens > right - left + 1:
                    minlens = right - left + 1
                sum1 -= nums[left]
                left += 1
        return minlens if minlens != n + 1 else 0