LeetCode-算法(一)

第一天-二分查找

704-二分查找

经典的二分查找代码应该熟练掌握

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        while(left<=right)
        {
            int mid = (right+left)/2;
            if(nums[mid]==target)
                return mid;
            else if(nums[mid]>target)
            {
                right = mid-1;
            }
            else
            {
                left = mid+1;
            }
        }
        return -1;
    }
};

278-第一个错误版本

同样基于二分查找
需要注意这里的接口用于判断当前是否为错误版本：

是错误版本时，我们想要知道是不是第一个错误版本，所以right=mid-1

不是错误版本，说明错误版本在后面则left=mid+1

最后返回left的值

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        long long left = 1;
        long long  right = n;
        while(left<=right)
        {
            long long mid = right-(right-left)/2;
            if(!isBadVersion(mid))
            {
                left = mid+1;
            }
            else
            {
                right = mid-1;
            }
        }
        return left;
    }
};

35-搜索插入位置

二分查找，返回left即可——想一想为什么？

第二天-双指针

977-有序数组的平方

思路1：暴力sort

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for(auto &it:nums)
        {
            it = it * it;
        }
        sort(nums.begin(), nums.end());
        return nums;
    }
};

思路2：双指针
考虑到原来的数组已经有序，平方后的数组必定是两头大中间小
所以利用双指针指向数组的首位，判断大小并往中级靠拢即可得到答案

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int front = 0;
        int rear = nums.size()-1;
        int n = nums.size();
        vector<int> ans(n);
        int pos = n-1;
        while(front<=rear)
        {
            int s1 = nums[front]*nums[front];
            int s2 = nums[rear]*nums[rear];
            if(s1>s2)
            {
                ans[pos] = s1;
                front++;
            }
            else
            {
                ans[pos] = s2;
                rear--;
            }
            pos--;
        }
        return ans;
    }
};

需要注意返回的答案需要从n-1开始填入元素

189-轮转数组

思路1：开辟辅助数组将位移后得到的数字进行填入
注意到其类似循环队列的性质
则有

int pos = (i+k)%n;
其中pos为辅助数组中保存元素的位置
i为源数组中元素的位置
k为轮转数
n为原数组大小

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        k = k%n;
        vector<int> ans(n);
        for(int i=0;i<n;i++)
        {
            int pos = (i+k)%n;
            ans[pos] = nums[i];
        }
        nums.clear();
        for(auto &it:ans)
        {
            nums.push_back(it);
        }
    }
};

思路2：利用双指针进行环状替换
需要注意当回到初始位置后可能某些数字没有遍历到，所以需要利用gcd(n, k)计算遍历的圈数，每遍历完一次，从下一个开始

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        k = k%n;
        int c = gcd(k, n);
        for(int i=0;i<c;i++)
        {
            int j = i;
            int pre = nums[j];
            do
            {
                int next = (j+k)%n;
                swap(nums[next], pre);
                j = next;
            }while(j!=i);
        }
    }
};

思路3：reverse函数
所谓轮转就是将后k个数提前，前n-k个数向后挪k个位置
则利用三次reverse即可达到该效果

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        reverse(nums.begin(), nums.end());
        int n = nums.size();
        k = k%n;
        reverse(nums.begin(), nums.begin()+k);//前k个数翻转
        reverse(nums.begin()+k, nums.end());//后n-k个数翻转
    }
};