LeetCode探索：初级算法（数组篇第一刷）

近来打算系统地学习一波数据结构与算法，因此根据LeetCode官方推出地经典面试题目清单开始刷题。本篇文章记录了初级算法中的数组篇，为了追求速度，我先大概地过一遍，每道题没有去分析多种解法，可能不是最优解，仅仅为我做题时的思路，若有什么错误的地方，欢迎大佬们指正哈！
ps:第一次写博客，格式之类的难免有所欠妥，还请大家谅解！

从排序数组中删除重复项

解法：双指针
解析：题中数组是有序的，因此重复的值肯定是相邻的，且从第2个值开始才有可能重复，所以遍历数组1~n-1。使用变量cur来作为当前指针，若数组中相邻的值重复，cur保持不变；若数组中出相邻的值不同，则让当前值覆盖cur中的值，cur指向下一个位置。

class Solution {
   
public:
    int removeDuplicates(vector<int>& nums) {
   
        int n = nums.size();
        if(n == 0) return 0;
        if(n == 1) return 1;
        int cur = 1;
        for(int i = 1; i < n; i++) {
     //从第二个值开始遍历
            if(nums[i] == nums[i-1]) {
   
                continue;
            } else {
   
                nums[cur++] = nums[i];
            }
        }
        return cur;
    }
};

时间复杂度：O(n) ，遍历一次数组
空间复杂度：O(1)， 需要用到常量空间

买卖股票的最佳时机 II

解法：贪心算法
解析：所有上涨交易日都买卖（赚到所有利润），所有下降交易日都不买卖（永不亏钱）。

class Solution {
   
public:
    int maxProfit(vector<int>& prices) {
   
        int res = 0;
        for(int i = 1; i < prices.size(); i++) {
   
            if(prices[i] - prices[i-1] > 0) 
                res += prices[i] - prices[i-1]; 
        }
        return res;
    }
};

时间复杂度：O(n) ，遍历一次数组
空间复杂度：O(1)， 需要用到常量空间

旋转数组

解法：使用反转
解析：这道题要求使用原地算法，因此不能开额外的数组。首先要注意的是k的大小，当k大于数组n的长度时，数组每移动n次，就回到了原来的位置，相当于没有改变位置。可以将k对n取模，减少不必要的时间消耗
ps：接下来我开始循环k次，一位一位地移动位置，结果超时了。后面看了官方题解，看到了一种捷径式解法：反转
超时代码：

class Solution {
   
public:
    void rotate(vector<int>& nums, int k) {
   
        int n = nums.size();
        k = k % n;
        while(k--) {
   
            int t = nums[n-1];   //最后一位的值
            for(int i = n-1; i >= 1; i--) {
   
                nums[i] = nums[i-1];
            }
            nums[0] = t;
        }
    }
};

时间复杂度：O(k * n) ，遍历k次数组
空间复杂度：O(1)， 需要用到常量空间

官方题解：

原始数组 ------------- : 1 2 3 4 5 6 7
反转所有数字后 ---- : 7 6 5 4 3 2 1
反转前 k 个数字后 - : 5 6 7 4 3 2 1
反转后 n-k 个数字后 : 5 6 7 1 2 3 4 --> 结果

class Solution {