刷题02 数组easy

1752.数组是否能经排序和轮转得到

如果整个数组非递减，返回true，如果只有两个子数列非递减，并且两个子序列之间是有序的，返回true。

先找到第一个不满足非递减的位置i，如果i==numsize，说明整个数组非递减。否则，就判断另一个子数组是否是非递减的，若不是，返回false，若是，则判断两个子数组之间是否有序，只需要判断nums[0]与nums[numsize-1]的大小。nums[0]是第一个子数组的最小值，nums[numsize-1]是第二个子数组的最大值。

bool check(int* nums, int numsSize) {//需要满足数组是非递减的，或者有两个子序列非递减，且两个子序列是有序的int i,j;for(i=1;i<numsSize;++i){if(nums[i-1]>nums[i]){break;}}if(i==numsSize){//数组非递减return true;}for(int j=i+1;j<numsSize;++j){//判断另一个子数组if(nums[j-1]>nums[j]){return false;}}if(nums[0]>=nums[numsSize-1]){//判断两个子数组是否有序，return true;}return false;
}

1800.最大升序子数组和

模拟，一次遍历。用cur记录当前最大子数组和，升序cur就加nums[i],破坏了升序就让cur=nums[i]

int maxAscendingSum(int* nums, int numsSize) {//模拟int ans=0,cur=0;for(int i=0;i<numsSize;++i){if(i==0||nums[i-1]<nums[i]){cur+=nums[i];if(cur>ans) ans=cur;}else{cur=nums[i];}}return ans;
}

1827.最少操作使数组递增

一次遍历，如果nums[i-1]>=nums[i]，就更新nums[i]。采用贪心的思想，遍历数组进行判断当前局部是否满足递增，不满足就进行操作使其递增。

int minOperations(int* nums, int numsSize){int ans=0;for(int i=1;i<numsSize;++i){if(nums[i-1]>=nums[i]){ans+=nums[i-1]+1-nums[i];nums[i]=nums[i-1]+1;}}return ans;
}

1909.删除一个元素使数组有序

该题可以住转化为找数组中是否有且仅有一个驼峰或者低谷元素，这里需要注意是三个元素都有严格的大小，只要有一个不满足就不行。

bool canBeIncreasing(int* nums, int numsSize) {if(numsSize<=2) return true;bool flag=true;//判断是否找到一个驼峰或者低谷for(int i=0;i<numsSize-1;++i){if(nums[i]>=nums[i+1]){if(flag){if(i-1<0||nums[i+1]>nums[i-1]) flag=false;//遇到的是驼峰else if(i+2>=numsSize||nums[i+2]>nums[i]) flag=false;//遇到的是低谷else return false;}else{//第二次遇到return false;}}}return true;
}

1979.找出数组的最大公约数

排序+辗转相除法

int gcd(int x,int y){//辗转相除法if(y==0){return x;}return gcd(y,x%y);
}
int cmp(void* a,void *b){return *(int*)a-*(int*)b;
}
int findGCD(int* nums, int numsSize) {qsort(nums,numsSize,sizeof(int),cmp);//排序return gcd(nums[0],nums[numsSize-1]);
}

1991.找到数组的中间位置

关键是左右侧元素相等即为 sum=total−nums[i]−sum

int findMiddleIndex(int* nums, int numsSize) {//左右侧元素相等即为 sum=total−nums[i]−sumint total=0;for(int i=0;i<numsSize;++i){total+=nums[i];}int sum=0;for(int i=0;i<numsSize;++i){if(2*sum+nums[i]==total){return i;}sum+=nums[i];}return -1;
}

2049.找出3位偶数

要点：3位数，偶数，且三个数字要不同，第一个数字不能是0，且不能有重复的答案，最后输出必须按升序排序

class Solution {
public:vector<int> findEvenNumbers(vector<int>& digits) {unordered_set<int> s;//用于去重int n=digits.size();for(int i=0;i<n;++i){for(int j=0;j<n;++j){for(int k=0;k<n;++k){if(digits[i]==0) continue;if(i==j||i==k||j==k) continue;int num=digits[i]*100+digits[j]*10+digits[k];if(num%2==0){s.insert(num);}}}}vector<int> res;for(int num:s){res.push_back(num);}sort(res.begin(),res.end());return res;}
};

2239.查找最接近0的数字

1.第一次想法：比较复杂，还用了排序，就是找正负交替的那来两个数

int cmp(void* a,void*b){return *(int*)a-*(int*)b;
}
int findClosestNumber(int* nums, int numsSize) {qsort(nums,numsSize,sizeof(int),cmp);int index=0;//第一个为正的数字while(index<numsSize&&nums[index]<0){index++;}if(index==0) return nums[index];//全为正if(index==numsSize) return nums[numsSize-1];//全为负if(abs(nums[index])>abs(nums[index-1])){return nums[index-1];}return nums[index];
}

2.想法二：就是找绝对值最小的数，直接一次遍历查找,用一个变量dis进行记录绝对值

int findClosestNumber(int* nums, int numsSize) {int res=nums[0];int dis=abs(nums[0]);for(int i=1;i<numsSize;++i){if(abs(nums[i])<dis){res=nums[i];dis=abs(nums[i]);}else if(dis==abs(nums[i])){//相等时需要记录比较大的那个，通常是正数if(nums[i]>res){res=nums[i];}}}return res;
}

2357.使数组中所有元素都等于0的最小操作次数

1.方法一：模拟，每次找出数组中的最小正数，然后依次减去该数，再判断当前数组中的最小正数

int fun(int *nums,int numsSize){//找出最小正数int mm=INT_MAX;for(int i=0;i<numsSize;++i){if(nums[i]>0&&nums[i]<mm){mm=nums[i];}}if(mm==INT_MAX) return 0;return mm;
}
int minimumOperations(int* nums, int numsSize){int ans=0;int m=fun(nums,numsSize);while(m!=0){for(int i=0;i<numsSize;++i){nums[i]-=m;}m=fun(nums,numsSize);ans++;}return ans;
}

2.方法二：哈希

由于每次减去一个数组中的最小的正数，只有当正数不相同时，需要操作的次数才会增加，因此问题转化为了找数组中有几个不同的正数。

class Solution {
public:int minimumOperations(vector<int>& nums) {unordered_set<int> s;//set天然去重for(int num:nums){if(num>0){s.emplace(num);}}return s.size();}
};

2395.两个和不相等的子数组

1.法一：暴力法两次循环

bool findSubarrays(int* nums, int numsSize) {for(int i=0;i<numsSize-1;++i){for(int j=0;j<numsSize-1;++j){if(i!=j){int a=nums[i]+nums[i+1];int b=nums[j]+nums[j+1];if(a==b){return true;}}}}return false;
}

2.法二：哈希表

class Solution {
public:bool findSubarrays(vector<int>& nums) {unordered_set<int> s;for(int i=0;i<nums.size()-1;++i){if(s.find(nums[i]+nums[i+1])!=s.end()){return true;}s.insert(nums[i]+nums[i+1]);}return false;}
};

2389.和有限的最长子序列

1、暴力解，排序后模拟

class Solution {
public:vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {vector<int> res;sort(nums.begin(),nums.end());for(int target:queries){int ans=0;int sum=0;for(int i=0;i<nums.size();++i){sum+=nums[i];ans++;if(sum>target){ans--;break;}}res.push_back(ans);}return res;}
};

2、排序后求前缀和，再进行二分查找

class Solution {
public:vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {vector<int> res;sort(nums.begin(),nums.end());for(int i=1;i<nums.size();++i){nums[i]+=nums[i-1];//求前缀和}for(int target:queries){int cur=upper_bound(nums.begin(),nums.end(),target)-nums.begin();//二分查找res.push_back(cur);}return res;}
};

2404.出现最频繁的偶数

用数组做哈希表，数字很大，占用空间不小。

int mostFrequentEven(int* nums, int numsSize) {int flag[100002]={0};int res=-1;int mmax=0;for(int i=0;i<numsSize;++i){if(nums[i]%2==0){flag[nums[i]]++;if(flag[nums[i]]>mmax||flag[nums[i]]==mmax&&nums[i]<res){mmax=flag[nums[i]];res=nums[i];}}}return res;
}

2108.找出数组中的第一个回文字符串

判断回文字符串，然后遍历判断。

class Solution {
public:bool fun(string str){int n=str.size();for(int i=0;i<n/2;++i){if(str[i]!=str[n-i-1]){return false;}}return true;}string firstPalindrome(vector<string>& words) {for(string str:words){if(fun(str)){return str;}}return "";}
};

2154.将找到的值乘以2

给你一个整数数组 nums ，另给你一个整数 original ，这是需要在 nums 中搜索的第一个数字。

接下来，你需要按下述步骤操作：

如果在 nums 中找到 original ，将 original 乘以 2 ，得到新 original（即，令 original = 2 * original）。
否则，停止这一过程。
只要能在数组中找到新 original ，就对新 original 继续重复这一过程。

此题用递归的思想。代码简洁，但开销较大。

int findFinalValue(int* nums, int numsSize, int original) {for(int i=0;i<numsSize;++i){if(nums[i]==original){return findFinalValue(nums,numsSize,original*2);}}return original;
}

2164.对奇偶下标分别进行排序

模拟，用两个数组分别记录奇偶下标的元素，分别进行排序之后，在写回nums数组中。

/*** Note: The returned array must be malloced, assume caller calls free().*/int cmp1(int *e1,int *e2) {//降序return *e2 - *e1;
}
int cmp2(int *e1,int *e2) {//升序return *e1 - *e2;
}
int* sortEvenOdd(int* nums, int numsSize, int* returnSize){*returnSize = numsSize;int n=(numsSize+1)/2;int odd[n],even[n],len1 = 0,len2 = 0,i;// 取出奇数和偶数for (i = 0; i < numsSize; i++) {if (i%2==1) {odd[len1++] = nums[i];} else {even[len2++] = nums[i];}}qsort(odd,len1,sizeof(int),cmp1);qsort(even,len2,sizeof(int),cmp2);for (i = len1 = len2 = 0; i < numsSize; i++) {if (i%2==1) nums[i] = odd[len1++];else nums[i] = even[len2++];}return nums;
}

2185.统计包含指定前缀的字符串

对字符串进行操作，复习strncmp（）函数：

int strncmp(const char *str1, const char *str2, size_t n) 把 str1 和 str2 进行比较，最多比较前 n 个字节。

返回值为：

按照ASCII值进行比较，str1-str2的数值就是返回值。
如果返回值 < 0，则表示 str1 小于 str2。
如果返回值 > 0，则表示 str2 小于 str1。
如果返回值 = 0，则表示 str1 等于 str2。

int prefixCount(char** words, int wordsSize, char* pref) {int res=0;int len=strlen(pref);for(int i=0;i<wordsSize;++i){if(strncmp(words[i],pref,len)==0){res++;}}return res;
}

2210.统计数组中的峰和谷的数量

此题的难点的是需要跨越多个值进行判断峰和谷，相等的数字应该跳过，需要比较的是不同的值。

int countHillValley(int* nums, int numsSize) {//从三个数中去找小于或大于两边的数组的个数,若数对中有两个数相等，就跳过相等的数去寻找下一个不相等的数由此构成新的数对，再判断是否符合条件int ans=0;int temp=nums[0];for(int i=1;i<numsSize-1;++i){if(nums[i]==temp) continue;//如果与前面一个数相等就跳过else if(nums[i]==nums[i+1]) continue;//如果与后面一个数相等就跳过else if(nums[i]>nums[i+1]&&nums[i]>temp){//遇到峰，ans加1ans++;}else if(nums[i]<nums[i+1]&&nums[i]<temp){//遇到谷，ans加1ans++;}temp=nums[i];//不同的数字就进行记录}return ans;
}

2016.增量元素之间的最大差值

题目：给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算 nums[j] - nums[i] 能求得的 最大差值 ，其中 0 <= i < j < n 且 nums[i] < nums[j] 。

返回 最大差值 。如果不存在满足要求的 i 和 j ，返回 -1 。

1.暴力解

int maximumDifference(int* nums, int numsSize) {int ans=-1;for(int i=0;i<numsSize;++i){for(int j=i+1;j<numsSize;++j){int cur=nums[j]-nums[i];if(cur>0&&cur>ans){ans=cur;}}}return ans;
}

2.前缀和

int maximumDifference(int* nums, int numsSize) {int ans=-1;int premin=nums[0];for(int i=1;i<numsSize;++i){if(nums[i]>premin){if(nums[i]-premin>ans){ans=nums[i]-premin;//ans=max(ans,nums[i]-premin)}}else{premin=nums[i];}}return ans;
}