LeetCode_数组
- 704.二分查找
- 1.题目描述
- 2. 做题前要想明白什么
- 3. 左闭右闭代码
- 4.左闭右开代码
- 5. 关于中间值溢出问题
- 6. 图解举例(左闭右闭)
- 27.移除元素
- 1. 题目描述
- 2. 暴力法
- 3. 快慢指针法
- 4. 双向双指针法
704.二分查找
1.题目描述
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例：
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
详情LeetCode题链接：https://leetcode.cn/problems/binary-search/
2. 做题前要想明白什么
注：本题前提已满足数组为有序数组，同时题目还强调数组中无重复元素，满足以上两点即可以使用二分查找法。
因为数组内一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的必要前提。
-
二分法的整体思想实际就是不断的循环区间，如何确定边界是重点。 比如到底是while(left < right) 还是 while (left <= right) ,是right = mid ，还是right = mid - 1？
-
首先要理解区间的定义，区间定义就是不变量。
在二分查找的过程中，要保持不变量，即在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。比如采用左闭右闭区间时，通过对比中间值和target值要确定下一次查找区间，那么下一次的查找区间也是左闭有闭区间。
-
区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。
-
个人理解：左闭右开和左闭右闭相比可以理解为，左闭右闭比左闭右开多一个假想数，如下图：
3. 左闭右闭代码
/**
* 思路：二分法的边界值是重点，灵魂是如何考虑区间，常用区间：
* 左闭右闭：[left,right],即当left=right是也成立，比如[1,1]所以边界可设为while(left<=right);当nums[mid]>target时，因为此时是右闭区间，此
* 区间是包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid-1；
* 左闭右开：[left,right）,即当left=right不成立，比如[1,1)所以边界可设为while(left<right);当nums[mid]>target时，因为此时是右开区间，此
* 区间是不包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid；
*
* 本次实现采用左闭右闭区间写法
* 时间复杂度O(logn),空间复杂度O(1)
*/
public int search(int[] nums, int target) {
//避免当target不存在于有序数组nums中造成多次循环运算
if (target < nums[0] || target > nums[nums.length -1]) {
return -1;
}
int left = 0, right = nums.length - 1;
while (left<=right){
int mid = left + ((right - left) >> 1);
if (nums[mid] == target)
return mid;
else if (nums[mid] > target)
right = mid - 1;
else if (nums[mid] < target)
left = mid + 1;
}
return -1;
}
4.左闭右开代码
/**
* 思路：二分法的边界值是重点，灵魂是如何考虑区间，常用区间：
* 左闭右闭：[left,right],即当left=right是也成立，比如[1,1]所以边界可设为while(left<=right);当nums[mid]>target时，因为此时是右闭区间，此
* 区间是包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid-1；
* 左闭右开：[left,right）,即当left=right不成立，比如[1,1)所以边界可设为while(left<right);当nums[mid]>target时，因为此时是右开区间，此
* 区间是不包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid；
*
* 本次实现采用左闭右开区间写法
* 时间复杂度O(logn),空间复杂度O(1)
*/
public int search(int[] nums, int target) {
//避免当target不存在于有序数组nums中造成多次循环运算
if (target < nums[0] || target > nums[nums.length -1]) {
return -1;
}
int left = 0, right = nums.length;
while (left < right){
int mid = left + ((right - left) >> 1);
if (nums[mid] == target)
return mid;
else if (nums[mid] > target)
right = mid;
else if (nums[mid] < target)
left = mid + 1;
}
return -1;
}
5. 关于中间值溢出问题
-
通常中间值一般写法： mid = (right+left)/2；
-
考到溢出和效率后优化使用： mid = (right-left) >>1+left
-
解释：
(right-left)/2+left 和 (right-left)>>1+left 都是用来计算两个数 left 和 right 之间的中点。它们都等价于 (right+left)/2。但是 (right-left)>>1+left 使用位移运算代替了除以 2，效率高一点。而且前面两种写法可以避免 int 溢出。
6. 图解举例(左闭右闭)
例如输入: nums = [-1,0,3,5,9,12], target = 9
27.移除元素
1. 题目描述
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
详情LeetCode题链接： https://leetcode.cn/problems/remove-element/
2. 暴力法
数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖.
采用暴力解法，两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组
代码逻辑：
/**
* 思路：
* 数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖.
* 采用暴力解法，两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组
* 时间复杂度：O(n^2)
* 空间复杂度：O(1)
*/
public int removeElement(int[] nums, int val) {
int len = nums.length;
for (int i = 0; i < len; i++){
if (nums[i] == val){
for (int j = i + 1; j< len; j++){
nums[i] = nums[j];
}
i --;
len --;
}
}
return len;
}
3. 快慢指针法
双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针：
快指针： 寻找新数组的元素 ，新数组就是不含有目标元素的数组
慢指针： 指向更新 新数组下标的位置
代码逻辑：
/**
* 思路：快慢指针法
* 数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖.
* 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作
* 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
* 慢指针：指向更新 新数组下标的位置
* 时间复杂度：O(n)
* 空间复杂度：O(1)
*/
public int removeElement(int[] nums, int val) {
int slowIndex = 0;
for (int fastIndex = 0; fastIndex < nums.length; fastIndex ++){
if (nums[fastIndex] != val){
nums[slowIndex] = nums[fastIndex];
slowIndex ++;
}
}
return slowIndex;
}
4. 双向双指针法
因为不考虑新数组内的顺序，可用相向双指针法
代码实现逻辑：
/**
* 思路：相向双指针法(因为不考虑新数组内的顺序，可用相向双指针法)
* 数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖.
* 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作
* 右指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
* 左指针：指向更新 新数组下标的位置
* 时间复杂度：O(n)
* 空间复杂度：O(1)
*/
public int removeElement(int[] nums, int val) {
int left = 0;
int right = nums.length -1;
//因为不考虑新数组内的顺序，将right移到从右数第一个值不为val的位置
while (right >= 0 && nums[right] == val) {
right --;
}
//因为不考虑新数组内的顺序，将right位置的元素移到left（覆盖），right位置移除
while (left <= right){
if (nums[left] == val){
nums[left] = nums[right];
right --;
}
left ++;
while (right >= 0 && nums[right] == val){
right --;
}
}
return left;
}
部分图解理解如下：
