代码随想录——Day 01

Day 1：数组01

1. 二分查找

leetcode：704. 二分查找 - 力扣（LeetCode）

#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;

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

int main(int argc, char *argv[])
{
	vector<int> s;
    int _num;
    int _target;
    while(cin>>_num){
        s.push_back(_num);
        if(cin.get() == '\n'){
            break;
        }
    }
	cin>>_target;
	
	Solution solution;
	int ret = solution.search(s,_target);
	cout<<ret<<endl;
	return 0;
}

注：

（1）left==right注意是否有意义

（2）区间是否闭合

（3）根据区间的闭合与否，确定边界赋值为md（开区间）、md+1（闭区间）或者md-1（闭区间）

附加题目

leetcode：35. 搜索插入位置 - 力扣（LeetCode）

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        while(left <= right){
            int md = (left + right) / 2;
            if(target < nums[md]){
                right = md-1;
            } else if (target > nums[md]){
                left = md+1;
            } else {
                return md;
            }
        }
        //如果没有找到，最后退出while的区间应该是[right-1, left]，所以直接return left
        return left;
    }
};

leetcode：34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm> // 包含 sort 函数所在的头文件
using namespace std;

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.size() == 0){
            return vector<int>{-1,-1};
        }
        int l=-1, r=-1;
        l = returnbound(nums,target-0.5);
        r = returnbound(nums,target+0.5);
        if(l == r){
            return vector<int>{-1,-1};
        }
        return vector<int>{l,r-1};
    }
    int returnbound(vector<int>& nums, double target_lr){
        int left=0;
        int right=nums.size()-1;
        //查找插入的位置
        while(left <= right){
            int mid = (left+right)/2;
            if(target_lr < nums[mid]){
                right = mid-1;
            } else if(target_lr > nums[mid]){
                left = mid+1;
            }
        }
        return left;
    }
};

int main(int argc, char *argv[])
{
	vector<int> _nums;
    int _num;
    int _target;
    while(cin>>_num){
        _nums.push_back(_num);
        if(cin.get() == '\n'){
            break;
        }
    }
	cin>>_target;
	
	Solution solution;
	vector<int> ret = solution.searchRange(_nums,_target);
	//cout<<ret<<endl;
    for(auto a :ret){
        cout<<a<<" ";
    }
	return 0;
}

这个题是在评论区看到一种解法：
直接查找target-0.5和target+0.5的插入位置，参考 35. 搜索插入位置 - 力扣（LeetCode）

 很巧妙的一种解法

要注意的点：
（1）这里的target±0.5是double类型的，不再是原来的int；

（2）如果数组中存在这个target的话，最后返回的有边界应该-1，因为我们的代码中是查找的插入位置，插入的有边界位置是+1的；

（3）如果returnbound函数return的左右边界相等，就说明数组中不存在这个target，应当返回{-1，-1}。

2. 移除元素

leetcode：27. 移除元素 - 力扣（LeetCode）

首先根据题目的要求，要确保最后的数组中已经删除了目标元素，而不是创建了一个新的数组

这个题最简单是就是暴力解法，挨个查找，找到以后就把这个元素删除，删除以后其后面的所有元素都向前移一位

再一个就是双指针

#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for(int fastIndex=0; fastIndex<nums.size(); fastIndex++){
            if(nums[fastIndex] != val){
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }
};

int main(int argc, char *argv[])
{
	vector<int> _nums;
    int _num;
    int _target;
    while(cin>>_num){
        _nums.push_back(_num);
        if(cin.get() == '\n'){
            break;
        }
    }
	cin>>_target;
	
	Solution solution;
	int ret = solution.removeElement(_nums,_target);
	cout<<ret<<endl;
	return 0;
}

 注：

（1）快慢指针只需要处理val不等于nums[fastIndex]的情况就可以，等于的情况下只需要让fastIndex++，继续去寻找要移动到前面来的元素即可

（2）主要是要先将fastIndex对应的值赋给slowIndex后再执行slowIndex++的操作！

附加题目

leetcode：26. 删除有序数组中的重复项 - 力扣（LeetCode）

待

leetcode：283. 移动零 - 力扣（LeetCode）

待

leetcode：844. 比较含退格的字符串 - 力扣（LeetCode）

待

leetcode：977. 有序数组的平方 - 力扣（LeetCode）

待

3. 有序数组的平方

leetcode：977. 有序数组的平方 - 力扣（LeetCode）

简单做法：先平方再排序

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm> // 包含 sort 函数所在的头文件
using namespace std;

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result;
        //先平方
        for(int i=0; i<nums.size(); i++){
            int sortnum = nums[i] * nums[i];
            result.push_back(sortnum);
        }
        //再排序
        sort(result.begin(),result.end());
    }
};

int main(int argc, char *argv[])
{
	vector<int> _nums;
    int _num;
    //int _target;
    while(cin>>_num){
        _nums.push_back(_num);
        if(cin.get() == '\n'){
            break;
        }
    }
	//cin>>_target;
	
	Solution solution;
	vector<int> ret = solution.sortedSquares(_nums);
	//cout<<ret<<endl;
    for(auto a :ret){
        cout<<a<<" ";
    }
	return 0;
}

双指针做法：

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

注：

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i];