代码随想录算法训练营第一天|704. 二分查找、27.移除元素

代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素

leetcode704.二分查找

leetcode链接：https://leetcode.cn/problems/binary-search/
代码随想录讲解思路：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

提示：

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

**思路：**看到题目中的关键字“n个元素有序”、“元素不重复”，想到用二分法。
**易错点：**要注意区间定义就是不变量（左闭右开，或是左闭右闭），每次循环对边界的处理都要遵循。

• while循环时，有两种方法：left < right, left <= right。这里我可以在前面定义好left和right之后，只考虑改变<还是<=。当然卡子哥固定区间left<right，改变right的值也可以；
• 在二分取middle的值时，要考虑区间边界处的值是否包括在内。以左闭右开为例，当nums[middle]<target时，由于区间是左闭的，则left应该取middle+1；当nums[middle]>target时，由于区间是右开的，则right应该取middle即可。
  下面是两种写法：
  写法一：区间左闭右闭。

Class Solution {
Public:
	int search(vector<int> &nums, int target) {
		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 return middle;
		}
		return -1;
	}
}	

写法二：区间左闭右开。

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

不要忘记定义middle为int型变量。
做题心得：由于不久前刚刷过这道题，所以大体的答题框架还记得，但是在写代码的时候忘了关键的区间定义为不变量，所以在middle赋值那里出了问题。做题要注意前面的区间定义和后面的二分法middle赋值的一致性。

leetcode 27.移除元素

leetcode链接：https://leetcode.cn/problems/remove-element/
代码随想录讲解思路：https://programmercarl.com/0027.%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0.html
**题目描述：**给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例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

**思路：**数组的元素在内存地址中是连续的，不能单独删除一个元素，而是需要覆盖掉。有两种解法：
**解法一：暴力解法。**先用一层循环查找到与val相等的元素位置，再用一层循环将此位置开的元素依次由后一个元素覆盖。
代码如下：

//时间复杂度：O(n^2)
//空间复杂度：O(1)
Class Solution {
public:
	int removeElement(vector<int> & nums, int val) {
		int size = nums.size();
		for(i = 0; i < size; i++) {
			if(nums[i] == val) {
				for(j = i+1; j < size; j++) {
					nums[j-1] = nums[j];
				}
				i--;// 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
				size--;
			}
		}
		return size;
	}
}

易错点：

• 第二层循环结束后是要将i也进行减1操作的
• 第二层循环的j的起始值必须是i+1,循环内的j跟着写，如果j的初始值写成i，会出现如下错误。

=================================================================
==42==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000a0 at pc 0x00000034c4e0 bp 0x7ffef0c45e60 sp 0x7ffef0c45e58
READ of size 4 at 0x6020000000a0 thread T0

**解法二：双指针法。**通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
快指针负责查找数组中与val相等的元素，慢指针指向更新后的新数组的下标位置。
**易错点：**双指针是将不等于val的元素复制到新数组，与val相等时，fast循环加1，slow指针不动，以此来更新数组。最终新数组的大小就是slow的下标，返回slow即可。

// 时间复杂度：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;
    }
};

第一天题目相对简单，但是自己细节的地方老是容易忽略，移除元素的双指针解法没有想到，任重道远唉。希望自己可以坚持下去，早日成为刷题高手。
PS：每天都要做实验花费很多时间，老师又管得紧，真的很难平衡。