11.24lk

解题思路：读题，升序数组，还没有重复，考虑使用二分法，

数组插入，考虑以下几种情况：

数组前面，数组中间，等于数组中的元素，数组后面。

也可以考虑暴力解法：
for(int i=0;i<nums.size(); i++）{
	if(nums[i]>=target){
	return i;
	}
}
return nums.size();


二分法：
class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int n = nums.size();
        int left =0;
        int right =n-1;
        while(left<=right){
            int middle =(left+right)/2;
            if(nums[middle]>target){
                right =middle -1;
            }else if(nums[middle]<target)
                left =middle+1;
            else{
                return middle;
            }
        }
        return right+1;
    }
};

完全平方数就是能被平方的整数，看起来是一个数，我们怎么使用二分法呢，其实也是一样的，16的开平方可能是1，2，3.。。。到16，本质上还是一个个套，只是二分法减少了遍历次数。

class Solution {
public:
    bool isPerfectSquare(int num) {
        if(num<1)
        return false;
        int left=1;
        int right=num;
        while(left<=right){
            int middle=(left+(right-left)/2);
            long temp = long(middle)*long(middle);
            if(temp==num){
                return true;
            }else if(temp<num){
                left=middle+1;
            }else{
                right=middle-1;
            }
        }
        return false;
    }
};

接下来看一道数组，逻辑都是一样的，难点在于要输出一个有两个或以上元素的数组，需要分情况来判断。

还是要考虑几种情况：
1.数组范围外，前面或者后面-1-1
2. 数组范围中，但不存在，输出-1-1
3. 数组范围中存在，并输出位置

#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result{-1,-1};
        if(nums.empty())
            return result;
        result[0] = findFirst(nums, target);
        result[1] = findLast(nums, target);
        return result;
    }
private:
    int findFirst(vector<int>& nums, int target){
        int index = -1;
        int left=0;
        int right =nums.size()-1;
        while(left<=right ){
            int middle = left+(right-left)/2;
            if(nums[middle]>target){
                right=middle-1;
            }
            else if(nums[middle]<target){
                left = middle+1;
            }else{
                index=middle;
                right=middle-1;
            }
        }
        return index;
    }
    int findLast(vector<int> & nums, int target){
        int index = -1;
        int left = 0;
        int right=nums.size()-1;
        while(left<=right){
            int middle=left+(right-left)/2;
            if(nums[middle]<target){
                left = middle+1;
            }else if(nums[middle]>target){
                right=middle-1;
            }else{
                index = middle;
                left=middle+1;
            }
        }
        return index;
    }

};

int main(){
    vector<int> nums ={};
    //vector<int> nums{5,7,7,8,8,10};
    //nums = [5,7,7,8,8,10], target = 6
    //nums = [5,7,7,8,8,10], target = 8
    //nums = [], target = 0
    int target = 0;
    Solution s;
    vector<int> result = s.searchRange(nums, target);
    cout<<"["<<result[0]<<","<<result[1]<<"]"<<endl; // 输出：[3,4]
    return 0;
}