喵,小喵爬天梯系列~美国大公司。
第二弹:整数数组。
1、Remove Element
题意:
给定一个数组和一个值,在原地删除与值相同的数字,返回新数组的长度。
元素的顺序可以改变,并且对新的数组不会有影响。
分析:
小喵的第一想法,竟然题目中用的是vector,直接用用迭代器删除就好了,虽然代码简单易写,但是时间复杂度去可能达到o(n^2)。
那么我们能不能在o(n)时间解决问题呢?题目要求删除数组中的指定的元素的值x,小喵开始从另一个角度分析问题,就是保留不是指定值x的所有数据,此时就出现的转机,小喵从k=0,i=0开始扫描,如果不是A[i]!=x就直接替换A[k++] = A[i],这句话对于是x的直接直接覆盖,相等与直接删除。
图例解释:
Code1:
int removeElement(vector<int> &A, int elem) {
// write your code here
int n = A.size();
int k = 0;
vector<int>::iterator it;
for (it = A.begin(); it != A.end(); ) {
if (elem == (*it)) {
++k;
A.erase(it);
}
else ++it;
}
return n - k;
}
Code2:
int removeElement(vector<int> &A, int elem) {
// write your code here
int n = A.size();
int k = 0;
for (int i=0;i<n;i++) {
if (elem != A[i]) {
A[k++] = A[i];
}
}
return k;
}
小喵总结:对于这类简单的题,每一个人都会直接有思路解决,这是我们需要思考一下,是否存在更好的算法,使得时间和空间更少。瞄~
2、Subarray Sum
题意:
给定一个整数数组,找到和为零的子数组。你的代码应该返回满足要求的子数组的起始位置和结束位置。
分析:
记录1~i的和sum[i],进行两层循环的遍历,直接得出答案,时间复杂度o(n^2)。能否o(n)时间解决,假设子数组i+1 ~ j的和为0,则有sum[j] - sum[i] = 0;等式变形sum[i] == sum[j],我们可以使用hash表记录,hash[sum[i] ] = i;当到达sum[j]时,hash[sum[j]] = i;则子数组的下标是[i+1, j]。
Code:
class Solution {
public:
/**
* @param nums: A list of integers
* @return: A list of integers includes the index of the first number
* and the index of the last number
* 返回子数组的和是0的下标的开始和结束(任意一个)。
*/
//if(sum[i] - sum[j] ==0 ) 存在
//sum[j] == sum[i]
//记录hash[sum[j]] = j
//if 有hash[sum[i]]存在就返回[hash[sum[i]]+1,,i]
vector<int> subarraySum(vector<int> nums){
vector<int> res;
map<int,int> hash;
hash[0] = -1;
int sum = 0;
for(int i=0;i<nums.size();i++){
sum=sum+nums[i];
if(hash.find(sum) != hash.end()){//存在这个值
res.push_back(hash[sum]+1);
res.push_back(i);
break;
}
hash[sum] = i;
}
return res;
}
};
小喵总结:还是等式的变换+哈希思想~
3、 Remove Duplicates from Sorted Array
题意:
给定一个排序数组,在原数组中删除重复出现的数字,使得每个元素只出现一次,并且返回新的数组的长度。
不要使用额外的数组空间,必须在原地没有额外空间的条件下完成。
分析:
不要使用额外的数组空间?需要在原数组上进行考虑,充分挖掘所有的有用的信息,对于排序的数组,我们得到nums[i] == nums[i-1]。原数组上删除,看一下第一个题的双指针法?用两个指针i,j,如果nums[i] != nums[i-1],出现的新的值,就有nums[j] = nums[i];
Code:
class Solution {
public:
/**
* @param A: a list of integers
* @return : return an integer
*/
int removeDuplicates(vector<int> &nums) {
// write your code here
if(nums.size()==0) return 0;
int i,j;
i=j=1;
for(i=1;i<nums.size();i++){
if(nums[i]!=nums[i-1]){
nums[j++]=nums[i];
}
}
return j;
}
};
小喵总结:双指针法和哈希思想。
4、Merge Sorted Array
题意:
合并两个排序的整数数组A和B变成一个新的数组。
你可以假设A具有足够的空间(A数组的大小大于或等于m+n)去添加B中的元素。
分析:
A有足够的空间,意味着我们不用开辟新的数组,使用归并的过程添加到将B数组的指,添加打A数组中即可,从后往前添加,因为我们要在空位置进行赋值很安全,避免覆盖A数组中的原来的值,从大到小进行归并即可。
Code:
class Solution {
public:
/**
* @param A: sorted integer array A which has m elements,
* but size of A is m+n
* @param B: sorted integer array B which has n elements
* @return: void
*/
void mergeSortedArray(int A[], int m, int B[], int n) {
// write your code here
int k=m+n-1;
m--; n--;
while(m>=0&&n>=0){
if(A[m]>=B[n]){
A[k--]=A[m--];
}
else A[k--]=B[n--];
}
while(n>=0){
A[k--]=B[n--];
}
}
};
小喵总结:如果面试过程中,没有明确提示你A的空间很大,你会向面试官询问吗?
5、Two Sum
题意:
给一个整数数组,找到两个数使得他们的和等于一个给定的数 target。
你需要实现的函数twoSum需要返回这两个数的下标, 并且第一个下标小于第二个下标。注意这里下标的范围是 1 到 n,不是以 0 开头。
分析:
最简的方法可以直接用两层循环进行判断nums[i] + nums[j] == target,返回[i,j]。如何降低时间复杂度,一般都是空间换时间,空间?因此想到hash表,分析nums[i] + nums[j] == target;变形得到,nums[j] == target - nums[i]; (这个变形思想在编程中很重要)。出现了等式,对于
nums[i],我们纪录hash[target - nums[i]] = i; 当便利到hash[ nums[j] ] 存在时,一定是hash[nums[j]] = i; 此时有nums[i] + nums[j] == target;返回[hash[nums[j]]+1, j+1]。
Code:
class Solution {
public:
/*
* @param numbers : An array of Integer
* @param target : target = numbers[index1] + numbers[index2]
* @return : [index1+1, index2+1] (index1 < index2)
* 使用hash纪录上一个值
*/
vector<int> twoSum(vector<int> &nums, int target) {
// write your code here
map<int, int> hash;
vector<int> res;
for(int i = 0;i < nums.size();i ++){
if(hash.find(nums[i]) != hash.end()){//已经存在targe-x = nums[i]
res.push_back(hash[nums[i]] + 1);
res.push_back(i + 1);
break;
}
hash[target - nums[i]] = i;
}
return res;
}
};
小喵总结:等式的变形很重要。瞄~
6、 Product of Array Exclude Itself
题意:
给定一个整数数组A。定义B[i] = A[0] * … * A[i-1] * A[i+1] * … * A[n-1], 计算B的时候请不要使用除法。
分析:
如果可以用除法,就很简单,纪录pro = phi _[1-n] A[i] (1-n所有元素的乘积)。B[i] = pro / A[i]。为什么不能用除法?因为计算机计算时,除法相对乘法慢很多,因此避免惩罚。(面试时就碰到的这个题),那只能用乘法,对于B[i] = A[0] * … * A[i-1] * A[i-1] * A[i+1] * … * A[n-1]。我们很容易想到遍历所有的i =[0,..n-1],先计算前一半[0 - i-1]的乘机,再计算后一半[i+1 - n-1]的乘机。注意到,前一半和后一半乘积都是连续的,我们可以提前存下来sum[i]作为0-i的乘积。sum1[i]纪录n-1 - i的乘积。此时B[i] = sum[i-1] * sum1[i+1];特殊处理一下开头和结束即可。复杂度O(n)+O(n)。
Code:
class Solution {
public:
/**
* @param A: Given an integers array A
* @return: A long long array B and B[i]= A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1]
*/
vector<long long> productExcludeItself(vector<int> &nums) {
// write your code here
vector<long long> A(nums.size(),1),B(nums.size(),1),res(nums.size(),1);
if(nums.size() == 1) return res;
A[0] = nums[0];
for(int i=1;i<nums.size();i++){
A[i] = A[i-1] * nums[i];
}
B[nums.size()-1] = nums[nums.size() - 1];
for(int j=nums.size()-2;j>=0;j--){
B[j] = B[j+1] * nums[j];
}
for(int i=0;i<nums.size();i++){
if(i==0){
res[i] = B[i+1];
}
else if(i == nums.size()-1){
res[i] = A[i-1];
}
else res[i] = A[i-1] * B[i+1];
}
return res;
}
};
7、First Missing Positive
题意:
给出一个无序的正数数组,找出其中没有出现的最小正整数。
例如:
如果给出 [1,2,0], return 3
如果给出 [3,4,-1,1], return 2
分析:
很容易想到进行排序之后便利。能否继续降低时间复杂度?我们排序的时候即使对n个数全部考虑,其实我们只需考虑1-n之间的数字即可。
例如数组的长度是n,对于数字i(1<= i <=n)。如果存在,那么在一个排序的数组中,它一定在第i-1个位置。因此,我们遍历所有的数,例如A[i],如果 1 <= A[i] <=n。它的位置一定在下标A[i] - 1处。因此我们只需交换到它所在的位置,完成排序,之后遍历一下,如果发现A[i-1] != i。i就是第一个丢失的正整数。
Code:
class Solution {
public:
/**
* @param A: a vector of integers
* @return: an integer
*/
int firstMissingPositive(vector<int> A) {
// write your code here
int len = A.size();
/**
* 我们不用管其他的值,只需要计算1-n之间的值是否在自己应该在位置即可
* 因此我们可以将任意一个1-n直接的值放到它应该在的位置即可。
* 之后遍历一遍,遇到第一个不在其位置的值就是丢失的值。
*/
for(int i=0;i<len;i++){
while(A[i]>0&&A[i]<=len&&A[A[i]-1]!=A[i]){//第i-1个位置的数不是i,注意while
swap(A[i],A[A[i]-1]);
}
}
for(int i=0;i<len;i++){
if(A[i]!=i+1) return i+1;
}
return len+1;
}
};
8、3Sum Closest
题意:
给一个包含 n 个整数的数组 S, 找到和与给定整数 target 最接近的三元组,返回这三个数的和。
分析:
如果是要求两个数的和最接近目标的值target,可以排序+二分,对于三个数,我们可以排序,然后固定一个值i, 从j = i + 1, r = n-1,进行二分得到结果。时间复杂度从直接暴力的O(n^3)降级到O(n^2)。
Code:
class Solution {
public:
/**
* @param numbers: Give an array numbers of n integer
* @param target: An integer
* @return: return the sum of the three integers, the sum closest target.
* 固定一个值,另外的两个指针进行二分
*/
int threeSumClosest(vector<int> nums, int target) {
// write your code here
sort(nums.begin(),nums.end());
int ans = nums[0] + nums[1] + nums[2];
for(int i=0;i<nums.size();i++){
int l = i+1,r = nums.size() - 1;
while(l < r){
int sum = nums[i] + nums[l] + nums[r];
if(abs(sum - target) < abs(ans - target)) ans = sum;
if(sum < target) l ++;
else r--;
}
}
return ans;
}
};
9、3Sum
题意:
给出一个有n个整数的数组S,在S中找到三个整数a, b, c,找到所有使得a + b + c = 0的三元组。
分析:
此题和上一题是一样的题,只是把target=0,要求得到所有的组合,这里我们需要注意的是,不要出现同样的组合。例如[-3,1,1,2],我们第一个选择-3,之后二分1+2-3=0。但是接下来还是1和2,又会出现1+2-3=0,因此我们排序后遇到连续相同的值,需要仅仅处理所有相同值的最后一个即可。
Code:
class Solution {
public:
/**
* @param numbers : Give an array numbers of n integer
* @return : Find all unique triplets in the array which gives the sum of zero.
*/
vector<vector<int> > threeSum(vector<int> &nums) {
// write your code here
int n = nums.size();
sort(nums.begin(), nums.end());
vector<vector<int> > result;
for(int i=0;i<n-2;i++){
if(i!=0 && nums[i] == nums[i-1]) continue; //防止出现相同的组合
int l=i+1,r=n-1;
int sum = - nums[i];
while(l<r){
if(nums[l] + nums[r] == sum){
vector<int> tmp;
tmp.push_back(nums[i]);
tmp.push_back(nums[l]);
tmp.push_back(nums[r]);
result.push_back(tmp);
l++;
r--;
//防止出现相同的值
while(nums[l-1] == nums[l]) l++;
while(nums[r+1] == nums[r]) r--;
}
else if(nums[l] + nums[r] < sum) l++;
else r--;
}
}
return result;
}
};
小喵总结:你能不能第一时间想到这些细节问题?
10、Partition Array
题意:
给出一个整数数组 nums 和一个整数 k。划分数组(即移动数组 nums 中的元素),使得:
所有小于k的元素移到左边
所有大于等于k的元素移到右边
返回数组划分的位置,即数组中第一个位置 i,满足 nums[i] 大于等于 k。
分析:
这个题,大家应该都能搞定,就是快排的一次划分。
Code:
class Solution {
public:
int partitionArray(vector<int> &nums, int k) {
// write your code here
if(nums.size() == 0) return 0;
int i=0,j=nums.size()-1;
while(1){
//i<=j 注意这一句
while(i<=j && nums[i]<k) ++i;
while(i<=j && nums[j]>=k) --j;
if(i>j) break;
else{
swap(nums[j],nums[i]);
--j; ++i;
}
}
return i;
}
};