文章目录
前言
今天本来要写模板编程的，但是，网上对模板编程的争论不休，我一时也拿不定主意。
这些都是次要的，最主要的是，我拿不定主意，就会瞎学。
并不是说有学无害，跟你说这些的人是害你的。
学，就要时间成本，我们是没有别的东西要学了吗？算法很好的话当初也不至于连笔试都不敢参加。
不说废话了，从头刷起。
删除排序数组中的重复项
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2gy9m/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
示例：
输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
思路都在注释中了，在原数组上维护一个二次数组，将第一次出现的数往前提：
int removeDuplicates(vector<int>& nums) {
int sz = nums.size();
if(sz == 0) //首先，不排除数组长度为0的情况
return 0;
int sz2 = 1; //sz2纪录留下来的元素数
int flag = nums[0]; //由于是有序列表，flag用来纪录当前所处位置的数值
for(int i = 1;i<sz;i++){
if(nums[i] != flag){ //如果前后数值不同，那就进来吧
if(i > sz2) //i>sz2，说明中间有了重复项
nums[sz2] = nums[i]; //那就把i处提到前面去
sz2++; //sz2继续往后走
flag = nums[i]; //切换一个flag了
}
}
return sz2;
}
买卖股票的最佳时机 II
给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:
输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:
输入: prices = [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2zsx1/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
思路其实也很简单，就是不断的寻找波峰和波谷。
那波峰和波谷又要怎么找，因为我根本不知道什么时候波峰，什么时候波谷，先波峰还是先波谷，中间迭代多少次也不知道。
没事的，波峰波谷在这么转，都在波里面，那就有办法。
代码实现（思路都在注释里了）：
int maxProfit(vector<int>& prices) {
int i = 1;
int sz = prices.size();
int buy = prices[0];
int sell = buy;
int price = 0;
while(i<sz){
//当股票一路上涨
while(i<sz && prices[i]>=prices[i-1]){
sell = prices[i];
i++;
}
//涨停板
price+=(sell-buy);
//当股票开始一路下跌
while(i<sz && prices[i]<=prices[i-1]){
buy = prices[i];
i++;
}
//跌完就该回去了
}
return price;
}
旋转数组
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
进阶：
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？
示例 1:
输入: nums = [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:
输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2skh7/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
思路：这个还要多说吗？左右手翻转定理嘛。
现在跟我伸出左手右手，背面向下，左右手平移互换位置。这就是我们的旋转嘛。
别急。
我们现在将左手翻转，再将右手翻转。
接着，将两只手作为整体翻转（有一只手会比较别扭，调整一下），认真看看，跟前面是不是一样的。
所以，代码实现：
void rotate(vector<int>& nums, int k) {
int sz = nums.size();
if(k<sz)
sz -= k
else
sz-=(k%sz);
reverse(nums.begin(),nums.begin()+sz);
reverse(nums.begin()+sz,nums.end());
reverse(nums.begin(),nums.end());
}
存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x248f5/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
思路：思路其实很明确，但是我想试一下哈希表。
bool containsDuplicate(vector<int>& nums) {
unordered_set<int> us;
for(int x:nums){
if(us.find(x)!=us.end())
return true;
us.insert(x);
}
return false;
}
只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
思路：这题不想浪费时间，位运算，不了解位运算的小伙伴建议整体的去了解一下，很重要的。
int singleNumber(vector<int>& nums) {
int x = nums[0];
for(int i = 1;i<nums.size();i++)
x = x^nums[i];
return x;
}
不再赘言。
两个数组的交集 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 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2y0c2/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
思路：思路很多，比方说先排个序啥的。
但是，我不用，我就要用哈希表，诶，就是练。
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int,int> um;
int sz1 = nums1.size();
int sz2 = nums2.size();
vector<int> temp;
if(sz1>sz2){
for(int x:nums1) //将大的插入哈希表
um[x]+=1;
for(int y:nums2){
if(um[y]>0){ //如果找到了
temp.push_back(y);
um[y]--;
}
}
}
else{
for(int x:nums2) //将大的插入哈希表
um[x]+=1;
for(int y:nums1){
if(um[y]>0){ //如果找到了
temp.push_back(y);
um[y]--;
}
}
}
return temp;
}
加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2cv1c/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
这个题啊，其实正常情况暴力求解，但是不排除那种一串9的。
其实对于一串就可以当做特例来解决，但是我没那兴趣。
我就想先将数组翻转过来，头部加个1，在转回去，诶，就是玩儿、
vector<int> plusOne(vector<int>& digits) {
reverse(digits.begin(),digits.end());
int i = 0;
while(i<digits.size()){
if(digits[i]!=9){
digits[i]+=1;
reverse(digits.begin(),digits.end());
return digits;
}
else
digits[i] = 0;
i++;
}
digits.push_back(1);
reverse(digits.begin(),digits.end());
return digits;
}
移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。
那这不就是快慢指针吗？
void moveZeroes(vector<int>& nums) {
int fast = 0;
int slow = 0;
int sz = nums.size();
while (slow < sz) {
while (slow < sz && nums[slow] != 0)
slow++;
if (fast <= slow)
fast = slow + 1;
for (; fast < sz; fast++) {
if (nums[fast] != 0) {
int temp = nums[slow];
nums[slow] = nums[fast];
nums[fast] = temp;
break;
}
}
slow++;
}
}
一篇八题。本篇结束。