算法笔记(代码随想录)

数组

二分法

基础二分法（找到则返回下标，找不到返回-1）

//版本一
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
        while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};
// 版本二
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

区别就是区间的选取不同

当选取左闭右闭区间时，循环判断条件为while (left <= right)，目标在左区间时if (nums[middle] > target) right = middle - 1;

当选取左闭右开区间时，循环判断条件为while (left < right)，目标在左区间时if (nums[middle] > target) right = middle;

若第一种：while (left <= right)且right = middle时[-1,0,3,5,9,12]，target =2会使l = r = 2,都指向3，此时中间值大于2但r不变，无限循环下去

若第二种：为while (left < right)且right = middle-1;时若输入的数组为【5】target=5，则会返回-1

二分法变式1（找到则返回下标，找不到返回应该插入的位置）

int searchInsert(int* nums, int numsSize, int target) {
    int l = 0,r = numsSize-1,mid;
    while(l<=r){
        mid = (l+r)/2;
        if(target == nums[mid]){
            return mid;
        }
        if(target > nums[mid]){
            l = mid + 1;
        }
        if(target < nums[mid]){
            r = mid - 1;
        }
    }
    return r+1;//关键点
}

最后左右都会指向同一个数

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

int findFirstPosition(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1, mid;
    int firstPosition = -1;
    while (left <= right) {
        mid = (left + right) / 2;
        if (nums[mid] == target) {
            firstPosition = mid;
            right = mid - 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return firstPosition;
}
int findLastPosition(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1, mid;
    int lastPosition = -1;
    while (left <= right) {
        mid = (left + right) / 2;
        if (nums[mid] == target) {
            lastPosition = mid;
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return lastPosition;
}
int* searchRange(int* nums, int numsSize, int target, int* returnSize) {
    int firstPosition, lastPosition;
    int* s = malloc(sizeof(int) * 2);
    *returnSize = 2;
    s[0] = -1, s[1] = -1;
    firstPosition = findFirstPosition(nums, numsSize, target);
    if (firstPosition == -1)
        return s;
    lastPosition = findLastPosition(nums, numsSize, target);
    s[0] = firstPosition, s[1] = lastPosition;
    return s;
}

求x的平方根

int mySqrt(int x) {
    if (x == 0 || x == 1) return x;
    long left = 1, right = x - 1, mid;
    while (left <= right) {
        mid = (left + right) / 2;
        if ((mid * mid == x) || (mid * mid < x) && ((mid + 1) * (mid + 1) > x))
            return mid;
        else if (mid * mid < x) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

数据可能会溢出，所以要用long

x的有效平方根

bool isPerfectSquare(int num) {
    if (num == 0 || num == 1)
        return true;
    long left = 1, right = num - 1, mid;
    while (left <= right) {
        mid = (left + right) / 2;
        if (mid * mid == num)
            return true;
        if ((mid * mid < num) && ((mid + 1) * (mid + 1) > num))
            return false;
        else if (mid * mid < num) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return false;
}