从排序数组中删除重复项
给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。
不要使用额外的数组空间,你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以“引用”方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
解析:
先排序。
快慢指针,一个指针i指向所有不重复的,j向后遍历所有数据,遇到不重复的,就存在下标i的位置,i++,j++
c++代码:
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if(nums.size()==0)
return 0;
sort(nums.begin(),nums.end());//从小到大排序
int i=0;
for(int j=1;j<nums.size();j++)
{
if(nums[i]!=nums[j])
{
i++;
nums[i]=nums[j];
}
}
return i+1;
}
};
买卖股票的最佳时机 II
给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。
注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。
示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天(股票价格 = 1)的时候买入,在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后,在第 4 天(股票价格 = 3)的时候买入,在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。
因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。
示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
解析:
贪心算法,后一个只要比前一个大就卖出
c++代码:
class Solution {
public:
int maxProfit(vector<int>& prices) {
int max=0,tmp;
for(int i=1;i<prices.size();i++)
{
tmp=prices[i]-prices[i-1];
if(tmp>0)
max=max+tmp;
}
return max;
}
};
旋转数组
给定一个数组,将数组中的元素向右移动 k 个位置,其中 k 是非负数。
示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:
输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:
尽可能想出更多的解决方案,至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的原地算法。
c++代码:
class Solution {
public:
void rotate(vector<int>& nums, int k) {
int n=nums.size();
if(k>n)
k=k%n;
//先反转
for(int i=0;i<n/2;i++)
{
int tmp=nums[i];
nums[i]=nums[n-1-i];
nums[n-1-i]=tmp;
}
//对0-k-1的翻转
for(int i=0;i<k/2;i++)
{
int tmp=nums[i];
nums[i]=nums[k-1-i];
nums[k-1-i]=tmp;
}
//对k-n的翻转
int p=0;
for(int i=k;i<k+(n-k)/2;i++)
{
int tmp=nums[i];
nums[i]=nums[n-1-p];
nums[n-1-p]=tmp;
p++;
}
}
};
存在重复元素
给定一个整数数组,判断是否存在重复元素。
如果任何值在数组中出现至少两次,函数返回 true。如果数组中每个元素都不相同,则返回 false。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
c++代码:
方法一:
两层循环
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
int n=nums.size();
if(n==0)
return false;
for(int i=0;i<n;i++)
{
int j;
for(j=i+1;j<n;j++){
if(nums[i]==nums[j])
return true;
}
if(i==n-1)
return false;
}
}
};
方法二:
利用hashset存储不重复的值的特性
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
unordered_set<int> hashset;
for(int i=0;i<nums.size();i++)
{
if(hashset.count(nums[i])>0)
return true;//存在说明重复
hashset.insert(nums[i]);
}
return false;
}
};
存在重复元素 II
给定一个整数数组和一个整数 k,判断数组中是否存在两个不同的索引 i 和 j,使得 nums [i] = nums [j],并且 i 和 j 的差的绝对值最大为 k。
示例 1:
输入: nums = [1,2,3,1], k = 3
输出: true
示例 2:
输入: nums = [1,0,1,1], k = 1
输出: true
示例 3:
输入: nums = [1,2,3,1,2,3], k = 2
输出: false
class Solution {
public:
bool containsNearbyDuplicate(vector<int>& nums, int k) {
unordered_map<int,int> hashmap;
for(int i=0;i<nums.size();i++)
{
if(hashmap.count(nums[i])>0)
{
int cha=abs(i-hashmap[nums[i]]);
if(cha<=k)
return true;
hashmap[nums[i]]=i;//不满足,更新一下位置,继续下一个寻找
}
hashmap.insert(make_pair(nums[i],i));
}
return false;
}
};
存在重复元素 III
给定一个整数数组,判断数组中是否有两个不同的索引 i 和 j,使得 nums [i] 和 nums [j] 的差的绝对值最大为 t,并且 i 和 j 之间的差的绝对值最大为 ķ。
示例 1:
输入: nums = [1,2,3,1], k = 3, t = 0
输出: true
示例 2:
输入: nums = [1,0,1,1], k = 1, t = 2
输出: true
示例 3:
输入: nums = [1,5,9,1,5,9], k = 2, t = 3
输出: false
class Solution {
public:
bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
set<long> s;
for(int i=0;i<nums.size();i++)
{
if(i>k)
s.erase(nums[i-k-1]);//维护一个大小为k的集合,次新加入一个值之后,去掉位于nums数组中此时左边界的元素nums[i-k-1]
auto it=s.lower_bound((long)nums[i]-t);//查找第一个大于或者等于nums[i]-t的数字
if(it!=s.end()&&(long)(*it)-nums[i]<=t)//从set集合中找出距离当前nums[i]比较近的数的集合,判断他们是否小于等于nums[i]+t
return true;
s.insert(nums[i]);
}
return false;
}
};
只出现一次的数字
给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。
说明:
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
解析:
其余每个只出现两次这个很关键
先排序,每隔两个比较一次i和i+1位置的是不是相等,只有一个的会不等。
c++代码:
class Solution {
public:
int singleNumber(vector<int>& nums) {
int n=nums.size();
sort(nums.begin(),nums.end());
for(int i=0;i+1<n;i=i+2)
{
if(nums[i]!=nums[i+1])
return nums[i];
}
return nums[n-1];
}
};
两个数组的交集
给定两个数组,编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]
说明:
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。
方法一:
对数组1和2都进行从到大排序,然后两个指针i,j挨个比较nums1[i]和nums2[j],相等就存入res中,不等就移动指针。比较完之后res中可能存在重复的,再删掉重复的。
注意:unique函数”删除”序列中所有相邻的重复元素(只保留一个)。此处的删除,并不是真的删除,而是指重复元素的位置被不重复的元素给占领了。它指向的是去重后容器中不重复序列的最后一个元素的下一个元素。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
if(nums1.empty()||nums2.empty())
return {};
sort(nums1.begin(),nums1.end());
sort(nums2.begin(),nums2.end());
vector<int> res={};
int n1=nums1.size(),n2=nums2.size();
int i=0,j=0;
while(i<n1&&j<n2)
{
if(nums1[i]<nums2[j])
i++;
else if(nums1[i]>nums2[j])
j++;
else
{
res.push_back(nums1[i]);
i++;
j++;
}
}
if(res.empty())
return {};
res.erase(unique(res.begin(), res.end()), res.end());//去掉重复的
return res;
}
};
方法二:
将nums1中的不重复值都存入hashset,然后遍历nums2,判断hashset中是否存在,存在就将其存入res中,因为结果中不能包含重复的,所以找到了一个重复的,记得把这个从hashset中移除
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
if(nums1.empty()||nums2.empty())
return {};
vector<int> res;
unordered_set<int> hashset;
for(int i=0;i<nums1.size();i++)
{
if(hashset.count(nums1[i])<=0)
hashset.insert(nums1[i]);
}
for(int j=0;j<nums2.size();j++)
{
if(hashset.count(nums2[j])>0)
{
res.push_back(nums2[j]);
hashset.erase(nums2[j]);
}
}
return res;
}
};
两个数组的交集II
给定两个数组,编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明:
输出结果中每个元素出现的次数,应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:
如果给定的数组已经排好序呢?你将如何优化你的算法?
如果 nums1 的大小比 nums2 小很多,哪种方法更优?
如果 nums2 的元素存储在磁盘上,磁盘内存是有限的,并且你不能一次加载所有的元素到内存中,你该怎么办?
c++代码:
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
int n1=nums1.size();
int n2=nums2.size();
vector<int> result;
sort(nums1.begin(),nums1.end());
sort(nums2.begin(),nums2.end());
for(int i=0,j=0;i<n1&&j<n2;)
{
if(nums1[i]<nums2[j])
i++;
else if(nums1[i]>nums2[j])
j++;
else
{
result.push_back(nums1[i]);
i++;
j++;
}
}
return result;
}
};
方法二:
新建一个hashmap,键为nums1的每个数字,值为出现的次数。
遍历nums2,如果这个数在nums1中出现了,就把他放在vector中,因为结果中可以出现相同的数字,所以需要把hashmap对应的值减1,如果等于0的话就删除这个键。
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
vector<int> res;
unordered_map<int,int> hashmap;
for(int i=0;i<nums1.size();i++)
{
if(hashmap.count(nums1[i])>0)
hashmap[nums1[i]]++;
hashmap.insert(make_pair(nums1[i],1));//pair(值,次数)
}
for(int j=0;j<nums2.size();j++)
{
if(hashmap.count(nums2[j])>0)
{
res.push_back(nums2[j]);
hashmap[nums2[j]]--;
if(hashmap[nums2[j]]==0)
hashmap.erase(nums2[j]);
}
}
return res;
}
};
加一
给定一个由整数组成的非空数组所表示的非负整数,在该数的基础上加一。
最高位数字存放在数组的首位, 数组中每个元素只存储一个数字。
你可以假设除了整数 0 之外,这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
c++代码:
class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
int i;
for(i=digits.size()-1;i>=0;i--)//从最后一位开始
{
if(digits[i]<9)
{
digits[i]++;
return digits;
}
else
digits[i]=0;
}
digits.insert(digits.begin(),1);
return digits;
}
};
移动零
给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作,不能拷贝额外的数组。
尽量减少操作次数。
解析:
找到不为0的数移动到数组的开始
c++代码:
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int n=nums.size();
int k=0;
for(int i=0;i<n;i++)
{
if(nums[i]!=0)
nums[k++]=nums[i];
}
for(int i=k;i<n;i++)
{
nums[i]=0;
}
}
};
两数之和
给定一个整数数组和一个目标值,找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案,且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
c++代码:
#include<vector>
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int len=nums.size();
vector<int> result;
for(int i=0;i<len;i++)
for(int j=i+1;j<len;j++)
{
if(nums[i]+nums[j]==target)
{
result.push_back(i);
result.push_back(j);
return result;
}
}
}
};
旋转图像
给定一个 n × n 的二维矩阵表示一个图像。
将图像顺时针旋转 90 度。
说明:
你必须在原地旋转图像,这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。
示例 1:
给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋转输入矩阵,使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]
示例 2:
给定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],
原地旋转输入矩阵,使其变为:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]
解析:
[
[1,2,3],
[4,5,6],
[7,8,9]
],
先交换对角线
9 6 3
8 5 2
7 4 1
再交换列
7 4 1
8 5 2
9 6 3
c++代码:
class Solution {
public:
void rotate(vector<vector<int>>& matrix) {
int n=matrix.size();
//交换对角线
int tmp;
for(int i=0;i<n;i++)
{
for(int j=0;j<n-i;j++)
{
tmp=matrix[i][j];
matrix[i][j]=matrix[n-1-j][n-1-i];
matrix[n-1-j][n-1-i]=tmp;
}
}
//交换列
for(int i=0;i<n/2;i++)
{
for(int j=0;j<n;j++)
{
tmp=matrix[i][j];
matrix[i][j]=matrix[n-1-i][j];
matrix[n-1-i][j]=tmp;
}
}
}
};
有的效率不高。。。日后再改善。还差一个数独,有点复杂