【LeetCode】代码随想录之数组

代码随想录

数组理论基础

C++的数组在内存空间中是连续的，但有区别与Vector与Array，Vector是一个容器，它的底层实现为数组。其中二维数组的内存空间也是连续的，C++与JAVA的区别在与可以给出真实的内存地址。

1.二分查找

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

C++:

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        int left = 0;
        int right= n-1;
        while (left <= right) {
            int mid = left + (right - left)/2;
            if (nums[mid] > target){
                right = mid - 1;
            }else if (nums[mid] < target) {
                left = mid + 1;
            }else {
                return mid;
            }
        }
        return -1;
    }
};

Python3:

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

二分查找中注意[a,b]与[a,b)可能是两种不同的写法。

2.移除元素

给你一个数组 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。

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

C++：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int cur = 0;
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            if (nums[i] == val) {
                continue;
            }else {
                nums[cur] = nums[i];
                cur++;
            }
        }
        return cur;
    }
};

Python3：

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

主要考察快慢指针的搭配使用，注意return时由于上次++在当前未使用所以可以直接当做大小返回，不需要在因为下标从0开始而+1。

3.有序数组的平方

【977.有序数组的平方】
力扣题目链接(opens new window)

给你一个按 非递减顺序 排序的整数数组 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]

C++：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        vector<int> result(n, 0);
        int k = n - 1;
        for (int i = 0, j = n - 1; i <=j;) {

            if (nums[i]*nums[i] < nums[j]*nums[j]) {
                result[k--] = nums[j]*nums[j];
                j--;
            }else{
                result[k--] = nums[i]*nums[i];
                i++;
            }
        }
        return result;
    }
};

Python3:

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

还是考察双指针的使用，C++代码中为了防止平方溢出直接使用的

  if (nums[i]*nums[i] < nums[j]*nums[j]) {
      result[k--] = nums[j]*nums[j];
      j--;
  }

4.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0;
        int left = 0;
        int result = INT32_MAX;
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            while (sum >= target) {
                int n = j - left + 1;
                result = result < n? result : n;
                sum-=nums[left++];
            }
        }
        return  result==INT32_MAX? 0 : result;
    }
};

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left = 0
        sum = 0
        result = float("inf")
        for i in range(len(nums)):
            sum+=nums[i]
            while sum >= target:
                temp = i - left + 1
                result  = min(result, temp)
                sum -= nums[left]
                left+=1
        return 0 if result == float("inf") else result

TODO:2023/4/17未完待续…