力扣面试之每日几题

1.轮转数组

思路一：将数组最后一个数用temp存储，其余往后移动一个，实现一次轮转，再嵌套k层循环，但是测试用例过多时会超时

思路二：先找一个备用数组将nums的值存入备用数组，找寻k次之后的数组下标与原数组下标（j）之间的关系，直接在nums上将备用数组的值写入：分为两种情况：1.当j+k小于数组的长度时，k次后的数组下标为j+k；2.当j+k大于数组长度时，k次后的数组下标为【(j+k)%数组长度】

代码如下：

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        if(nums.size()!=1){
        int backup[nums.size()];
        for(int i=0;i<nums.size();i++){
            backup[i]=nums[i];
        }
        for(int j=0;j<nums.size();j++){
            if(j+k>=nums.size()){
                nums[(j+k)%nums.size()]=backup[j];
            }
            else{
                nums[j+k]=backup[j];
            }
        }
        }
        
    }
};

但是这个方法虽然不会超时，但是会有额外的空间消耗

官方题解：

数组翻转（很巧妙的想法！）：

当我们将数组的元素向右移动 k次后，尾部 k mod n个元素会移动至数组头部，其余元素向后移动 k mod n 个位置。

先将所有的数组元素翻转，将前【0-k mod n-1】数组元素翻转，再将其余的翻转就能得到答案。

class Solution {
public:
    void reverse(vector<int>& nums, int start, int end) {
        while (start < end) {
            swap(nums[start], nums[end]);
            start += 1;
            end -= 1;
        }
    }

    void rotate(vector<int>& nums, int k) {
        k %= nums.size();
        reverse(nums, 0, nums.size() - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.size() - 1);
    }
};

2.买股票的最佳时机

思路一：双层循环，一个指向当前元素，遍历当前元素之后的元素，如果有比它大的，算出差值（back），定义一个max，如果back更大则max值替换为back。

但是双层循环，当元素过多时，会超出时间限制。

思路二：遍历一遍数组，计算每次 到当天为止 的最小股票价格和最大利润。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
       int cost = INT_MAX, profit = 0;
        for (int price : prices) {
            cost = min(cost, price);
            profit = max(profit, price - cost);
        }
        return profit;
    }
};