【代码随想录】数组-C++

数组是存放在连续内存空间上的相同类型数据的集合：

• 数组下标都是从0开始的；
• 数组内存空间的地址是连续的；
• vector的底层实现是array，但是vector是容器不是数组；
• 数组元素不能删除只能覆盖；

704.二分查找

// 第一种写法：[left，right]区间左闭右闭
// while (left <= right)：left==right有意义
// left = mid + 1
// right = mid - 1
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;
            else
                right = mid - 1;
        };
        return -1;
    }
};

二分法注意判定条件是left<=right，更新规则为left=mid+1和right=mid-1

// 第二种写法：[left，right)区间左闭右开
// while (left < right)：left==right无意义
// left = mid + 1
// right = mid
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;
            else
                right = mid - 1;
        };
        return -1;
    }
};

27.移除元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

利用快慢指针，慢指针指向当前判定元素，快指针指向一个不为val的元素：当快指针指向的元素值为val时，快指针向右移；用快指针指向的元素更新慢指针的元素。

977. 有序数组的平方

// 方法一：平方后排序
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int i=0; i<nums.size(); i++){
            nums[i] *= nums[i];
        }
        sort(nums.begin(), nums.end());
        return nums;
    }
};

// 方法二：双指针
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k=nums.size()-1;
        vector<int> ans(nums.size(), 0);
        for (int left=0,right=nums.size()-1;left<=right;){
            if (nums[left]*nums[left] < nums[right]*nums[right]){
                ans[k--]=nums[right]*nums[right];
                right--;
            }
            else{
                ans[k--]=nums[left]*nums[left];
                left++;
            }
        }
        return ans;
    }
};

209. 长度最小的子数组

// 滑动窗口
// 当前窗口总和>=target后，right++，之后判断left是否可以++
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int s=0; // 子序列之和
        int left = 0;
        int ans = INT32_MAX;
        for (int right=0;right<nums.size();right++){
            s += nums[right];
            while (s>=target){
                s -= nums[left++];
                ans = min(ans,right-left+2);
            };
        }
        return ans == INT32_MAX ? 0:ans;
    }
};

59. 螺旋矩阵II

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> ans(n, vector<int> (n, 0));
        int count = 1; // 用于赋值
        int loop = n/2; // 圈数
        int mid = n/2; // 中心位置
        int startx = 0;
        int starty = 0;
        int offset = 1; // 右边界偏移
        while (loop--){
            for (int j=starty;j<n-offset;j++){
                ans[startx][j]=count++;
            }
            for (int i=startx;i<n-offset;i++){
                ans[i][n-offset]=count++;
            }
            for (int j=n-offset;j>offset-1;j--){
                ans[n-offset][j]=count++;
            }
            for(int i=n-offset;i>offset-1;i--){
                ans[i][starty]=count++;
            }
            offset++;
            startx++;
            starty++;
        }
        if (n%2){
            ans[mid][mid]=count;
        }
        return ans;
    }
};