这里记录了LeetCode初级算法中数组的一些题目:
加一
本来想先转成整数，加1后再转回去；耽美想到测试的例子考虑到了这个方法的笨重，所以int类型超了最大范围65536，导致程序出错。
class Solution {
public:
vector plusOne(vector& digits) {
int m=digits.size();
int old=0;
for(int i=0;i a;
while(re!=0)
{
a.insert(a.begin(),re%10);
re=re/10;
}
return a;
}
}; 下面完全是从数组的角度进行的思考:分析了各种情况综合得出代码:
class Solution {
public:
vector plusOne(vector& digits) {
int m=digits.size();
if(m==1&&digits[0]==0) {digits[0]+=1;return digits;}
for(int i=m-1;i>=0;i--)
{
if(digits[i]==9) digits[i]=0;
else {digits[i]+=1;return digits;}
}
if(digits.front()==0) digits.insert(digits.begin(),1);
return digits;
}
}; 此外还有一种解法:
这种方法就很机智的将进位carry这个思路加了进来，如果carry=0的话就说明暂时没有进位，可以直接返回；如果有进位的话继续操作。最后在循环结束后，如果还有进位，说明要加1，用和前一个解法的insert就可以了。
class Solution {
public:
vector plusOne(vector& digits) {
if (digits.empty()) return digits;
int carry = 1, n = digits.size();
for (int i = n - 1; i >= 0; --i) {
if (carry == 0) return digits;
int sum = digits[i] + carry;
digits[i] = sum % 10;
carry = sum / 10;
}
if (carry == 1) digits.insert(digits.begin(), 1);
return digits;
}
}; 从排序数组中删除重复项
下面是我最初始的想法，通过循环，遍历的这一项等于前一项的话，就通过迭代器iterator it将这一项清除掉，如果不相等就将count加1；这样觉得很完美，但是实际上每次将这一项清除掉的时候，vector的总长度就发生变化了，所以会导致出错！！！下面是错误代码:
class Solution {
public:
int removeDuplicates(vector& nums) {
int count=1;
if(nums.size()==0) return 0;
if(nums.size()==1) return 1;
for(int i=1;i::iterator it=nums.begin()+i-1;
nums.erase(it);
}
else count++;
}
return count;
}
}; 更换思路，发现题目中有这样的一句话:不需要理会新的数组长度后面的元素；这叫告诉我们，可以把不需要的元素弄到后面去或者将我们需要的元素弄到前面来，所以有了下面的解法:
class Solution {
public:
int removeDuplicates(vector& nums) {
int m=nums.size();
if(m==0) return 0;
if(m==1) return 1;
int count=0;
for(int i=1;i 只出现一次的数字
#include
using namespace std;
class Solution {
public:
int singleNumber(vector& nums) {
if(nums.size()==0) return 0;
if(nums.size()==1) return nums[0];
int m=nums.size();
sort(nums.begin(),nums.end());
for(int i=1;i 移动零
典型的双指针的应用！！
class Solution {
public:
void moveZeroes(vector& nums) {
int fast=0,slow=0;
int m=nums.size();
while(fast 两个数组的交集
首先就想到两个for循环，然后在新创建的vector中进行排序、去重，输出即可:
class Solution {
public:
vector intersection(vector& nums1, vector& nums2) {
//sort(nums1.begin(),nums1.end());
//sort(nums2.begin(),nums2.end());
vector c;
if(nums1.size()==0||nums2.size()==0) return c;
for(int i=0;i::iterator iter = unique(c.begin(), c.end());
c.erase(iter, c.end());
return c;
}
};
这里说一下如何对vector进行去重，想到的方法有两个:利用set或者unique()，其中unique()函数是这样的，
sort (a, a + n);
vectorv (a, a + n);
vector::iterator it = unique(v.begin(), v.end() );
v.erase (it, v.end() );//这里就是把后面藏起来的重复元素删除了 而set则更为简单，设置一个set，再将vector的数据重新传入set中，时间复杂度较小而且较方便。
然后，看了看大神的代码，他直接用了set的取集合交集set_intersection，代码如下:
class Solution {
public:
vector intersection(vector& nums1, vector& nums2) {
set s1(nums1.begin(),nums1.end()),s2(nums2.begin(),nums2.end()),res;
set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(res,res.begin()));
return vector(res.begin(),res.end());
}
}; 更多关于set的用法可以参看这一篇博客
两个数组的交集2
class Solution {
public:
vector intersect(vector& nums1, vector& nums2) {
vector c;
if(nums1.size()==0||nums2.size()==0) return c;
sort(nums1.begin(),nums1.end());
sort(nums2.begin(),nums2.end());
int i=0,j=0;
while(inums2[j])
j++;
else
i++;
}
return c;
}
}; ValidSudoku
这道题真的挺有意思，但因为不用判断数独是否有解，所以降低了很多难度。基本思路是这样的，针对每一行每一列判断是否有重复的数字，然后在针对每个九宫格进行判断。而判断是否重复的方法挺巧妙的，就是利用数组小表的唯一性。a[nums]初始值为0，出现过一次数字后变为1，nums是由所填数字的下表来决定的，举个例子就会清楚了:假如第一行里有两个7，nums[7】初始值为0，在第一次7的时候nums[7]变为了1，在第二次遇到7的时候由于之前已经变为了7，简单的判断语句就能发现这里实际上出现了问题。下面贴上代码:
class Solution {
public:
bool isValidSudoku(vector>& board) {
int i,j,k,l,map[10];
if(board.size()!=9 || board[0].size()!=9)return false;
for(i=0;i<9;i++){
memset(map,0,sizeof(map));
for(j=0;j<9;j++){
if(board[i][j]=='.')continue;
if(board[i][j]<'0' || board[i][j]>'9')return false;
int num=board[i][j]-'0';
if(map[num])return false;
map[num]=1;
}
}
for(j=0;j<9;j++){
memset(map,0,sizeof(map));
for(i=0;i<9;i++){
if(board[i][j]=='.')continue;
int num=board[i][j]-'0';
if(map[num])return false;
map[num]=1;
}
}
for(i=0;i<9;i+=3){
for(j=0;j<9;j+=3){
memset(map,0,sizeof(map));
for(k=i;k 旋转图像
这道题我感觉比较奇怪，思路比较好像用的是reverse与swap，我看了别人的代码只是先后顺序不同而已，但是自己的代码(注释掉的)却在输入为44矩阵时不能执行reverse，而自己在私下测试了reverse确实是可以将44矩阵执行reverse操作的，自己的想法是先将行数倒置，然后沿着主对角线进行swap()操作，得到最终结果。而我最终的代码，是先交换在倒置，我认为先后顺序是没有问题的，但是程序却没有执行reverse的操作，就很奇怪。
class Solution {
public:
void rotate(vector>& matrix) {
/*
for(int i=0;i 买卖股票的最佳时机2
股票衡量是否为利润是基于前一天的价格和今天的价格来比较的，知道这个就好做了。
class Solution {
public:
int maxProfit(vector& prices) {
int l = prices.size();
if(l <= 0) {
return 0;
}
int max = 0;
for(int i=1; i 0) {
max += (prices[i] - prices[i-1]);
}
}
return max;
}
};