刷题记录：Easy 数组(持续更新)

1.下标、迭代器等基本操作

1：两数之和：力扣

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>m;
        int n=nums.size();
        for(int i=0;i<n;++i){
            if(m.count(target-nums[i])){
                return {i,m[target-nums[i]]};
            }
            m[nums[i]]=i;
        }
        return {};
    }
};

26：删除有序数组中的重复项-力扣

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n=nums.size();
        for(auto it=nums.begin();it!=nums.end();){
            if(it!=nums.begin() && *it==*(it-1)){
                nums.erase(it);
            }else{
                ++it;
            }
        }
        return nums.size();
    }
};

27：移除元素-力扣

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        for(auto it=nums.begin();it!=nums.end();){
            if(*it==val){
                nums.erase(it);
            }else{
                ++it;
            }
        }
        return nums.size();
    }
};

283. 移动零 - 力扣（LeetCode）

也可用双指针，类似于冒泡思想

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int i=0;
        for(auto it=nums.begin();it!=nums.end(),i<nums.size();++i){
            if(*it==0){
                nums.erase(it);
                nums.emplace_back(0);
            }else{
                ++it;
            }
        }
    }
};

2.动态规划（Easy）

53.最大子数组和-力扣

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre=0;
        int maxAns=nums[0];
        for(auto &i:nums){
            pre=max(pre+i,i);
            maxAns=max(maxAns,pre);
        }
        return maxAns;
    }
};

 746. 使用最小花费爬楼梯 - 力扣（LeetCode）

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n=cost.size();
        vector<int>dp(n+1);
        dp[0]=dp[1]=0;
        for(int i=2;i<=n;++i){
            dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[n];
    }       
};

 

 

3.二分查找

704. 二分查找 - 力扣（LeetCode）

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left=0,right=nums.size()-1;

        while(left<=right){
            int mid=left+(right-left)/2;
            if(nums[mid]==target){
                return mid;
            }else if(nums[mid]<target){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return -1;
    }
};

 剑指 Offer 11. 旋转数组的最小数字 - 力扣（LeetCode）

此题也可用deque来做

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

 

 

4.哈希表(unordered_map,unordered_set)

 217. 存在重复元素 - 力扣（LeetCode）

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int,int>m;
        for(auto &i:nums){
            if(m.count(i)){
                return true;
            }
            m[i]++;
        }
        return false;
    }
};

 219. 存在重复元素 II - 力扣（LeetCode）

 与上一题差不多，只不过添加了一些约束

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        int n=nums.size();
        unordered_map<int,int>m;
        for(int i=0;i<n;++i){
            int t=nums[i];
            if(m.count(t) && i-m[t]<=k){
                return true;
            }
            m[t]=i;
        }
        return false;
    }
};

5.数学

136. 只出现一次的数字 - 力扣（LeetCode）

异或

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans=0;
        for(auto &i:nums){
            ans^=i;
        }
        return ans;
    }
};

169. 多数元素 - 力扣（LeetCode）

 摩尔投票法（拉帮结派）

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int count=0;
        int target=nums[0];
        for(auto &i:nums){
            if(count==0){
                target=i;
            }
            if(i==target){
                ++count;
            }else{
                --count; 
            }
        }
        return target;
    }
};

剑指 Offer 53 - II. 0～n-1中缺失的数字 - 力扣（LeetCode） 

异或

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int res=0;
        int n=nums.size();
        for(int i=0;i<n;++i){
            res^=nums[i];
        }
        for(int i=0;i<=n;++i){
            res^=i;
        }
        return res;
    }
};

 6.双指针

977. 有序数组的平方 - 力扣（LeetCode）

利用好数组升序的特性，确定正负交界，双指针操作类似于归并排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int pivot=-1;
        for(int i=0;i<nums.size();++i){
            if(nums[i]<0){
                pivot=i;
            }else{
                break;
            }
        }
        vector<int>ans;
        int p1=pivot,p2=pivot+1;
        while(p1>=0 && p2<nums.size()){
            int pow1=nums[p1]*nums[p1];
            int pow2=nums[p2]*nums[p2];
            if(pow1<pow2){
                ans.emplace_back(pow1);
                --p1;
            }else{
                ans.emplace_back(pow2);
                ++p2;
            }
        }
        while(p1>=0){
            ans.emplace_back(nums[p1]*nums[p1]);
            --p1;
        }
        while(p2<nums.size()){
            ans.emplace_back(nums[p2]*nums[p2]);
            ++p2;
        }
        return ans;
    }
};

283. 移动零 - 力扣（LeetCode）

类似冒泡的思想

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int left=0,right=0;
        while(right<nums.size()){
            if(nums[right]!=0){
                swap(nums[left],nums[right]);
                left++;
            }
            right++;
        }
    }
};

350. 两个数组的交集 II - 力扣（LeetCode） 

这里很巧妙，肯定是短的数组先到末尾，结束循环，&&而不是||

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        int p1=0,p2=0;
        //4 5 9
        //4 4 8 9 9
        vector<int>ans;
        while(p1<nums1.size() && p2<nums2.size()){
            if(nums1[p1]<nums2[p2]){
                p1++;
            }else if(nums1[p1]>nums2[p2]){
                p2++;
            }else{
                ans.emplace_back(nums1[p1]);
                p1++;
                p2++;
            }
        }
        return ans;
    }
};

 

7.滑动窗口

219. 存在重复元素 II - 力扣（LeetCode）

一种滑动窗口的实现方式，很值得学习一下

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_set<int>s;
        
        for(int i=0;i<nums.size();++i){
            if(i>k){
                s.erase(nums[i-k-1]);
            }
            if(s.count(nums[i])){
                return true;
            }
            s.emplace(nums[i]);
        }
        return false;
    }
};

 

。一些模板题

剑指 Offer 29. 顺时针打印矩阵 - 力扣（LeetCode）

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if(matrix.empty())return {};
        int left=0,right=matrix[0].size()-1;
        int top=0,bottom=matrix.size()-1;
        vector<int>ans;
        while(true){

            for(int i=left;i<=right;++i){
                ans.emplace_back(matrix[top][i]);
            }
            if(++top>bottom)break;
            for(int i=top;i<=bottom;++i){
                ans.emplace_back(matrix[i][right]);
            }
            if(--right<left)break;
            for(int i=right;i>=left;--i){
                ans.emplace_back(matrix[bottom][i]);
            }
            if(--bottom<top)break;
            for(int i=bottom;i>=top;--i){
                ans.emplace_back(matrix[i][left]);
            }
            if(++left>right)break;
        }
        return ans;
    }
};

 剑指 Offer 40. 最小的k个数 - 力扣（LeetCode）

TopK问题， 优先队列（堆排序）

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        priority_queue<int,vector<int>,greater<>>q;
        vector<int>ans;
        for(auto &i:arr){
            q.push(i);
        }
        for(int i=0;i<k;++i){
            ans.emplace_back(q.top());
            q.pop();
        }
        return ans;
    }
};

 1984. 学生分数的最小差值 - 力扣（LeetCode）

最大值最小化， 排序往往是解决办法

class Solution {
public:
    int minimumDifference(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end());
        int MIN=INT_MAX;
        for(int i=0;i+k-1<nums.size();++i){
            MIN=min(MIN,nums[i+k-1]-nums[i]);
        }
        return MIN;
    }
};