_1LeetCode代码随想录算法训练营第一天C++数组 | 704.二分查找、35.搜索插入位置、34.在排序数组中查找元素的第一个和最后一个位置、27 移除元素

_1LeetCode代码随想录算法训练营第一天C++数组 | 704.二分查找、35.搜索插入位置、34.在排序数组中查找元素的第一个和最后一个位置、27 移除元素

LeetCode 题目列表：

• 704.二分查找
• 35.搜索插入位置
• 34.在排序数组中查找元素的第一个和最后一个位置
• 27 移除元素

704. 二分查找

代码随想录地址：https://programmercarl.com/0704.%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE.html

题目

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

易错点

根本原则：遍历到每个区间，并且不重复遍历任何一个元素。

while(left < right)
还是
while(left <= right)

if(nums[middle]>target)  //此时更新右区间
{
    right = middle;
    还是
    right = middle - 1;
}

循环不变量

左闭右闭区间：[left, right]

左闭右开区间：[left, right)

一般实际应用中不会使用左开右闭区间(left, right]

自己选择一个区间原则，然后写代码的时候严格遵守这个原则。

左闭右闭写法

/*
 * @lc app=leetcode.cn id=704 lang=cpp
 *
 * [704] 二分查找
 */

// @lc code=start
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;//左闭右闭区间选择nums.size() - 1，左闭右开区间选择nums.size()
        while(left <= right)//左闭右闭区间选择<=，左闭右开区间选择<
        {
            int middle = left + ((right - left)/2);//等同于(left+right)/2，此句是为了防止溢出，因为left+right可能会超出int的取值范围
            if(nums[middle] > target)
                right = middle - 1;//左闭右闭区间选择middle-1，左闭右开区间选择middle
            else if(nums[middle] < target)
                left = middle + 1;
            else
                return middle;
        }
        return -1;
    }
};
// @lc code=end

左闭右开写法

/*
 * @lc app=leetcode.cn id=704 lang=cpp
 *
 * [704] 二分查找
 */

// @lc code=start
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();//左闭右闭区间选择nums.size() - 1，左闭右开区间选择nums.size()
        while(left < right)//左闭右闭区间选择<=，左闭右开区间选择<
        {
            int middle = left + ((right - left)/2);//等同于(left+right)/2，此句是为了防止溢出，因为left+right可能会超出int的取值范围
            if(nums[middle] > target)
                right = middle;//左闭右闭区间选择middle-1，左闭右开区间选择middle
            else if(nums[middle] < target)
                left = middle + 1;
            else
                return middle;
        }
        return -1;
    }
};
// @lc code=end

27. 移除元素

代码随想录地址：https://programmercarl.com/0027.%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0.html

题目

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以**「引用」**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

数组理论基础

代码随想录地址：https://programmercarl.com/%E6%95%B0%E7%BB%84%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

数组是连续存储的，删除一个元素，要将其后面的所有元素往前移动一位。

库函数的使用

如果一个问题直接使用库函数就可以解决，那么建议不要使用库函数；如果一个库函数只是解决问题的一小部分问题，并且在了解该库函数的实现机制以及其复杂度的情况下可以使用库函数。(我个人认为，如果自己能写出比库函数时间复杂度更低的代码，自己写代码会比较好。)

双指针的思路

fast：快指针指向新数组所需要的元素。

slow：慢指针指向需要更新元素的下标。

代码实现

使用暴力方法(即两个for循环)的复杂度为O(n^2)，使用双指针的方法的时间复杂度为O(n)。

/*
 * @lc app=leetcode.cn id=27 lang=cpp
 *
 * [27] 移除元素
 */

// @lc code=start
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for(int fast = 0;fast < nums.size();fast++)
        {
            if(nums[fast] != val)
            {
                nums[slow] = nums[fast];
                slow++;//当执行了移动操作时，将slow++
            }
        }
        return slow;//当循环结束时，slow正好表示数组大小
    }
};
// @lc code=end

练习

35. 搜索插入位置

题目

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

提示:

• 1 <= nums.length <= $10^4$
• -$10^4$ <= nums[i] <= $10^4$
• nums 为 无重复元素 的 升序 排列数组
• -$10^4$ <= target <= $10^4$

代码

/*
 * @lc app=leetcode.cn id=35 lang=cpp
 *
 * [35] 搜索插入位置
 */

// @lc code=start
class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        //如果元素存在于数组中，则就是题目704的问题
        int left = 0;
        int right = nums.size() - 1;
        int rightBorder = 0;//赋初值，此题对于初值是不在乎的
        while(left <= right)
        {
            int middle = left + ((right - left)/2);//等同于(left+right)/2，此句是为了防止溢出，因为left+right可能会超出int的取值范围
            if(nums[middle] > target)//就是说target在middle的左边
                right = middle - 1;//此时更新右索引的值
            else if(nums[middle] < target)//就是说target在middle的右边
            {
                left = middle + 1;//此时更新左索引的值
                rightBorder = left;//此处记录右边界，是为了返回 按顺序插入的位置所作的工作
            }    
            else
                return middle;//相等的话就返回当前的位置
        }
        //不相等的话要返回按顺序插入的位置
        return rightBorder;
    }
};
// @lc code=end

34. 在排序数组中查找元素的第一个和最后一个位置

题目

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

• 0 <= nums.length <= $10^5$
• -$10^9$ <= nums[i] <= $10^9$
• nums 是一个非递减数组
• -$10^9$ <= target <= $10^9$

思路

三种情况

• 情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
• 情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
• 情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}

代码

/*
 * @lc app=leetcode.cn id=34 lang=cpp
 *
 * [34] 在排序数组中查找元素的第一个和最后一个位置
 */

// @lc code=start
class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftBorder = getLeftBorder(nums,target);
        int rightBorder = getRightBorder(nums,target);
        //情况1
        if(leftBorder == -2 || rightBorder == -2)
            return {-1, -1};//此处不能返回[]数组的原因是，vector没有这样的构造函数
        //情况3
        if(rightBorder - leftBorder > 1)
            return {leftBorder + 1, rightBorder - 1};
        //情况2
        return {-1, -1};
    }
private:
    int getLeftBorder(vector<int>& nums, int target)
    {
        int left = 0;
        int right = nums.size() - 1;
        int leftBorder = -2;//对于题目35的rightBorder，初值是不重要的，但此处的初值是重要的，是为了后面的区分
        while(left <= right)
        {
            int middle = left + ((right - left)/2);//防止溢出
            if(nums[middle] >= target)//要将等于放在这里
            {
                right = middle - 1;
                leftBorder = right;
            }
            else
                left = middle + 1;
        }
        return leftBorder;
    }

    int getRightBorder(vector<int>& nums, int target)
    {
        int left = 0;
        int right = nums.size() - 1;
        int rightBorder = -2;//对于题目35的rightBorder，初值是不重要的，但此处的初值是重要的，是为了后面的区分
        while(left <= right)
        {
            int middle = left + ((right - left)/2);//防止溢出
            if(nums[middle] > target)
                right = middle - 1;
            else//要将等于放在这里
            {
                left = middle + 1;
                rightBorder = left;
            }                
        }
        return rightBorder;
    }
};
// @lc code=end