LeetCode刷题——算法入门第二天

“前情回顾”：
LeetCode刷题——算法入门第一天
经过昨天的学习，我们学习了二分查找，而今天我们将学习双指针。
双指针从广义上来说，是指用两个变量在线性结构上遍历而解决的问题。
对于数组，指两个变量在数组上相向移动解决的问题；
对于链表，指两个变量在链表上同向移动解决的问题，也称为「快慢指针」问题。
开始上题

一开始看到此题，脑子里立刻冒出来思路，先平方再排序：

class Solution {
public:
    void QuickSort(vector<int>&arr,int begin,int end){
        if(begin>end)
            return;
        int tmp = arr[begin];
    int i = begin;
    int j = end;
    while(i != j){
        while(arr[j] >= tmp && j > i)
            j--;
        while(arr[i] <= tmp && j > i)
            i++;
        if(j > i){
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }
    arr[begin] = arr[i];
    arr[i] = tmp;
    QuickSort(arr, begin, i-1);
    QuickSort(arr, i+1, end);
    }

    vector<int> sortedSquares(vector<int>& nums) {
        for(int i=0;i<nums.size();i++){
            nums[i]=nums[i]*nums[i];
        }
        QuickSort(nums,0,nums.size()-1); 
        return nums;        
    }
};

这里我采用快速排序，效率较高
随后我看了看官方的题解，发现了双指针这一解法：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n);
        for (int i = 0, j = n - 1, pos = n - 1; i <= j;) {
            if (nums[i] * nums[i] > nums[j] * nums[j]) {
                ans[pos] = nums[i] * nums[i];
                ++i;
            }
            else {
                ans[pos] = nums[j] * nums[j];
                --j;
            }
            --pos;
        }
        return ans;
    }
};

首先很直观的一点，该解法较简略，代码长度大大减短。而且时间复杂度和空间复杂度都较低，分别为：
时间复杂度：O(n)，其中 n 是数组 nums 的长度。
空间复杂度：O(1)。除了存储答案的数组以外，我们只需要维护常量空间。
该算法的使用两个指针分别指向数组的起始点和终点，因为数组本是非递减排序，所以只需要比较两个指针对应的平方值然后更新指针即可。

接下来是旋转数组问题：

这个题是学习算法遇到的第一个中登难度的题，第一感觉和前边的简单题差别不大，尤其示例里很明显，每次轮转实际上是把最后的元素移到开头，然后超时错误。。。

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
       for(int i=0;i<k;i++){
           nums.insert(nums.begin(),nums.back());
           nums.pop_back();
       }
    }
};

这也发现了我的一个误区，以前一直默认c++自带的函数时间复杂度是O（1），但其实上述代码中的Insert函数时间复杂度是O(n)，导致程序的时间复杂度为n*k，导致超时。

痛定思痛，我再次审视这个题目，发现放在全局来看，第i个元素其实移动到底（i+k）%n的位置上，于是得出答案：

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> newArr(n);
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        nums.assign(newArr.begin(), newArr.end());
    }
};

但该算法实际并不是最优解，空间复杂度较高。
然后翻阅官方题解：

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);
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/rotate-array/solution/xuan-zhuan-shu-zu-by-leetcode-solution-nipk/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

官方解释：

该算法从翻转的角度来理解该题，即实际的转换为先对整个数组开头和结尾互换位置，然后1，n-1互换位置，类推。。。。然后对小于k的部分和大于k的部分进行类似操作并得到最终结果。