代码随想录 -- 数组

二分查找

力扣题目链接

题目描述

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

示例：

输入: nums = [-1,0,3,5,9,12], target = 9     
输出: 4       
解释: 9 出现在 nums 中并且下标为 4  

题解

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int low=0,high = nums.size()-1,mid;
        while (low<=high){
            mid=(low+high)>>1;
            if (nums.at(mid) == target)return mid;
            else if(nums.at(mid)>target) high = mid-1;
            else low = mid+1;
        }
        return -1;
    }
};

移除元素

力扣题目链接

题目描述

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

题解：暴力解法

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        size_t len = nums.size();
        for (int i = 0; i < len; ++i) {
            if(nums[i] == val){
                for (int j = i; j < len-1; ++j) {
                    nums[j] = nums[j+1];
                }
                --i;// 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                --len;
            }
        }
        return len;
    }
};

题解：双指针法

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

有序数组的平方

力扣题目链接

题目描述

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

题解：暴力解法

先平方后排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (auto &item: nums)
            item*=item;
        sort(nums.begin(),nums.end());
        return nums;
    }
};

题解：双指针法

分析：
数组是有序的，那么数组里面的元素平方之后的最大值要么是开头的要么是结尾的，依次移动

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        size_t n = nums.size()-1;
       size_t slowIndex{0},fastIndex{n};
       vector<int>result(n+1,0);
        while (slowIndex<fastIndex) {
            int s1 = nums[slowIndex] * nums[slowIndex],
                    s2 = nums[fastIndex] * nums[fastIndex];
            if (s1 > s2){
                result[n--] = s1;
                ++slowIndex;
            }
            else {
                result[n--] = s2;
                --fastIndex;
            }
        }
         result[0]=nums[slowIndex]*nums[slowIndex];
        return result;
    }
};

代码简写的版本：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};

长度最小的子数组

力扣题目链接

题目描述

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

题解：暴力解法

已经超时

class Solution {
public:
    int minSubArrayLen(int target, vector<int> &nums) {
        size_t len = nums.size();
        if (len == 0)return 0;
        int min_o = INT_MAX;
        for (int i = 0; i < len; ++i) {
            int sum{0};
            for (int j = i; j < len; ++j) {
                sum += nums[j];
                if (sum >= target){
                    min_o = (min_o < (j - i + 1)) ? min_o : (j - i + 1);
                    break;
                }
            }
        }
        return min_o == INT_MAX ? 0 : min_o;
    }
};

题解：滑动窗口（双指针）

class Solution {
public:
    int minSubArrayLen(int target, vector<int> &nums) {
        size_t len = nums.size();
        // beg：起始位置 sum：总和 result：最终的结果
        int beg{0}, sum{0}, result{INT_MAX};
        // i是一个中止位置
        for (int i = 0; i < len; ++i) {
            sum += nums[i];
            // 持续更新起始位置，当满足条件的时候起始位置前移
            while (sum >= target) {
                // 选择最小窗口
                result = (result < (i - beg + 1)) ? result : (i - beg + 1);
                sum -= nums[beg++];
            }
        }
        return result == INT_MAX ? 0 : result;
    }
};

螺旋矩阵II

力扣题目链接

题目描述

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

题解

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
    	vector<vector<int>>v(n,vector<int>(n,0));
        //offset偏移量 count总数
    	int offset{1},start_x{0},start_y{0},i{0},j{0},count{1};
    	// 循环n/2次 奇数特殊处理一下 偶数直接结束
        int loop = n/2;//循环的次数
    	while(loop--){
    		for (j = start_y; j < n - offset; ++j)
    			v[start_x][j] = count++;

    		for (i = start_x ; i < n - offset; ++i)
    			v[i][j] = count++;

    		for (; j > start_y; --j)
    			v[i][j] = count++;

    		for (; i > start_x; --i)
    			v[i][j] = count++;

    		++start_x;
    		++start_y;
    		++offset;
    	}
    	if (n%2!=0)
    		v[n/2][n/2] = count;
    	return v;
    }
};