代码随想录算法训练营第一天：二分查找，移除元素，有序数组的平方

一.数组

1.要点：

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的数组的元素是不能删的，只能覆盖。

C++中二维数组在地址空间上是连续的。（java就不是了）

二.二分查找

二分查找有两种方法

1.target在左闭右闭[left, right] 

• while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
• if (nums[middle] > target) target 偏小，在left与middle的左侧， right 要赋值为 middle - 1，left不用改变，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1
• 时间复杂度：O(log n)
• 空间复杂度：O(1)

int search(int* nums, int numsSize, int target) {
    int light = 0, right = numsSize - 1;
    int middle = 0;
    while (light <= right) {
        middle = left + (right - left)/2;
        if (nums[middle] < target) {
            light = middle + 1;
        } else if (nums[middle] > target) {
            right = middle - 1;
        } else {
            return middle;
        }
    }
    return -1;
}

2.target在左闭右开[left, right）

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• 注意注意：与上文的情况一样，但right 要赋值为 middle 

int search(int* nums, int numsSize, int target) {
    int left= 0, right = numsSize ;
    int middle = 0;
    while (left < right) {
        middle = left + (right - left)/2;
        if (nums[middle] < target) {
            left = middle + 1;
        } else if (nums[middle] > target) {
            right = middle;
        } else {
            return middle;
        }
    }
    return -1;
}

这次做这道题，别忘了if，else if，else，还要注意左闭右闭right=middle-1,左闭右开right=middle；

• mid = (right + left) // 2这种写法会发生上溢问题。

  • 那么对于两个都接近 2147483647的数字而言，它们相加的结果将会溢出，变成负数。所以，为了避免溢出情况的发生，我们不采用这种写法。

  • mid = left + (right - left) // 2 从左指针到右指针的一半距离 + 左指针的下标 才是符合题的下标位置。

三、LeetCode 27-移除元素

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

暴力解法

这里注意数组是不可以删除的，只能进行覆盖。

所以覆盖的思路可以用以下的代码思路

for(int i=0;i<length;i++){
            if(nums[i]==val){
                for(int j=i+1;j<length;j++){
                    nums[j-1]=nums[j];
                }
                i--;
                length--;
            }
            
        }

注意i处的值被删除了，j=i+1，指向i的后一个值，通过nums[j-1]=num[j]来实现

特别注意：length要同时--。

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

双指针

这里要理解双指针如何运作，必须知道快慢指针的含义：

快指针：记录寻找删除指定元素后的新数组的元素

慢指针：根据快指针所指向的值，不断的更新新数组中的元素

这里引用Carl的图

// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

四、977. 有序数组的平方 - 力扣（LeetCode）

暴力排序就没啥说的了，这道题的官方解题思路我是没有想到的，也让我重新认识了双指针的用法。

如动画所示：

题解：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int>result(nums.size(),0);//这里定义一个新的数组
        int k=nums.size()-1;
        for(int i=0,j=nums.size()-1;i<=j;){//注意i，j的大小
            if(nums[i]*nums[i]>nums[j]*nums[j]){
                result[k]=nums[i]*nums[i];
                i++;
                k--;
            }else {
                result[k]=nums[j]*nums[j];
                j--;
                k--;
            }
        }
        return result;
    }
};