# day01
## 题目信息 [704. 二分查找](https://leetcode.cn/problems/binary-search/) :
- 题目链接: https://leetcode.cn/problems/binary-search/
- 题目描述:
给定一个 `n` 个元素有序的(升序)整型数组 `nums` 和一个目标值 `target` ,写一个函数搜索 `nums` 中的 `target`,如果目标值存在返回下标,否则返回 `-1`。
## 解法一: {{**左闭右闭区间**}}
### 代码实现
```java
public int search1(int[] nums,int target){
//左闭右闭区间
if(target < nums[0] || target > nums[nums.length - 1]){
return -1;
}
int left = 0;
int right = nums.length - 1;
while (left <= right){
int mid = left + ((right - left) >> 1);
if(nums[mid] == target){
return mid;
} else if (nums[mid] < target) {
left = mid + 1;
}
else{
right = mid - 1;
}
}
return -1;
}
```
### 错误代码:
```java
public int search(int[] nums,int target){
if(target < nums[0] || target > nums[nums.length]){
return -1;
}
int left = 0;
int right = nums.length;
int mid = left + ((right - left) << 1);
while (left <= right){
if(nums[mid] == target){
return nums[mid];
} else if (nums[mid] < target) {
left = mid + 1;
}
else{
right = mid - 1;
}
}
return -1;
}
}
```
### 解题思路
第一种写法,我们定义 target 是在一个在左闭右闭的区间里,**也就是[left, right] (这个很重要非常重要)**。
区间的定义这就决定了二分法的代码应该如何写,**因为定义target在[left, right]区间,所以有如下两点:**
- while (left <= right) 要使用 <= ,因为left == right是有意义的,所以使用 <=
- if (nums[middle] > target) right 要赋值为 middle - 1,因为当前这个nums[middle]一定不是target,那么接下来要查找的左区间结束下标位置就是 middle - 1
例如在数组:1,2,3,4,7,9,10中查找元素2,如图所示:
![[Pasted image 20240731111303.jpg]]
## 解法二: {{**左闭右开区间**}}
### 代码实现
```java
public int search2(int [] nums,int target){
//左闭右开区间
int left = 0;
int right = nums.length;
while(left < right){
int mid = left + ((right - left) >> 1);
if(nums[mid] < target){
left = mid + 1;
} else if (nums[mid] > target) {
right = mid;
}else return mid;
}
return -1;
}
```
### 错误代码:
```java
public int search2(int [] nums,int target){
int left = 0;
int right = nums[nums.length - 1];
while(left < right){
int mid = left + ((right - left) >> 1);
if(nums[mid] < target){
left = mid + 1;
} else if (nums[mid] > target) {
right = mid;
}else return mid;
}
return -1;
}
```
### 解题思路
如果说定义 target 是在一个在左闭右开的区间里,也就是[left, right) ,那么二分法的边界处理方式则截然不同。
有如下两点:
- while (left < right),这里使用 < ,因为left == right在区间[left, right)是没有意义的
- if (nums[middle] > target) right 更新为 middle,因为当前nums[middle]不等于target,去左区间继续寻找,而寻找区间是左闭右开区间,所以right更新为middle,即:下一个查询区间不会去比较nums[middle]
在数组:1,2,3,4,7,9,10中查找元素2,如图所示:(**注意和方法一的区别**)
![[Pasted image 20240731111356.jpg]]
## 总结
**一、模版(认真看看3种情况之间的关系)**
1. **左右闭区间**:**[a, b]**
- 循环条件
- ⭐ `start ≤ end`
- 边界更新操作
- `tmp = (start + end) / 2`
- `if (tmp < target) start = tmp + 1;`
- `if (tmp > target) end = tmp - 1;`
2. **左闭右开:[a, b)**
- 循环条件
- ⭐ `start < end` (左右相等没意义)
- 边界更新操作
- `tmp = (start + end) / 2`
- `if (tmp < target) start = tmp + 1;`
- ⭐ `if (tmp > target) end = tmp;` (开区间不需要越位)
3. **~~左开右闭:(a, b]~~(一般不考虑这种情况,前两种已经足够)**
- 循环条件
- ⭐ `start < end` (左右相等没意义)
- 边界更新操作
- `tmp = (start + end) / 2`
- ⭐`if (tmp < target) start = tmp;`(开区间不需要越位)
- `if (tmp > target) end = tmp - 1;`
**二、**⭐⭐**需要考虑的边界值条件**
1. **数组为空(nums: [])**
2. **指针越界(start > length - 1;end < 0)**
**三、其他需要考虑的点**
- 数据类型是否溢出(int → long)
**四、进阶规律:结束状态时,right指针的位置有规律**
## 题目信息 ---27. 移除元素
- 题目链接: [https://leetcode.cn/problems/remove-element/](https://leetcode.cn/problems/remove-element/)
- 题目描述:给你一个数组 `nums` 和一个值 `val`,你需要 **[原地](https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95)** 移除所有数值等于 `val` 的元素。元素的顺序可能发生改变。然后返回 `nums` 中与 `val` 不同的元素的数量。
## 解法一: {{双指针}}
### 代码实现
```java
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];
}
}
return slowIndex;
}
```
### 解题思路
双指针法(快慢指针法): **通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。**
定义快慢指针
- 快指针:寻找新数组的元素 ,新数组就是不含有目标元素的数组
- 慢指针:指向更新 新数组下标的位置
很多同学这道题目做的很懵,就是不理解 快慢指针究竟都是什么含义,所以一定要明确含义,后面的思路就更容易理解了。
删除过程如下:
![[27.移除元素-双指针法.gif]]
**双指针法(快慢指针法)在数组和链表的操作中是非常常见的,很多考察数组、链表、字符串等操作的面试题,都使用双指针法。**
## 解法二: {{双指针优化}}
### 代码实现
```java
public int removeElement2(int[] nums, int val) {
int left = 0;
int right = nums.length;
while (left < right) {
if (nums[left] == val) {
nums[left] = nums[right - 1];
right--;
} else {
left++;
}
}
return left;
}
```
### 解题思路
**思路**
如果要移除的元素恰好在数组的开头,例如序列 [1,2,3,4,5],当 val 为 1 时,我们需要把每一个元素都左移一位。注意到题目中说:「元素的顺序可以改变」。实际上我们可以直接将最后一个元素 5 移动到序列开头,取代元素 1,得到序列 [5,2,3,4],同样满足题目要求。这个优化在序列中 val 元素的数量较少时非常有效。
实现方面,我们依然使用双指针,两个指针初始时分别位于数组的首尾,向中间移动遍历该序列。
**算法**
如果左指针 left 指向的元素等于 val,此时将右指针 right 指向的元素复制到左指针 left 的位置,然后右指针 right 左移一位。如果赋值过来的元素恰好也等于 val,可以继续把右指针 right 指向的元素的值赋值过来(左指针 left 指向的等于 val 的元素的位置继续被覆盖),直到左指针指向的元素的值不等于 val 为止。
当左指针 left 和右指针 right 重合的时候,左右指针遍历完数组中所有的元素。
这样的方法两个指针在最坏的情况下合起来只遍历了数组一次。与方法一不同的是,**方法二避免了需要保留的元素的重复赋值操作**。
## 题目信息[977. 有序数组的平方](https://leetcode.cn/problems/squares-of-a-sorted-array/)
- [题目链接]( https://leetcode.cn/problems/squares-of-a-sorted-array/)
- 题目描述: 给你一个按 **非递减顺序** 排序的整数数组 `nums`,返回 **每个数字的平方** 组成的新数组,要求也按 **非递减顺序** 排序。
## 解法一: {{双指针法}}
### 代码实现
```java
public int[] sortedSquares(int[] nums) {
int right = nums.length - 1;`
int left = 0;
int [] result = new int[nums.length];
int index = result.length - 1;
while (left <= right){
if(nums[left]*nums[left] > nums[right]*nums[right]){
result[index--] = nums[left] * nums[left];
++left;
}else{
result[index--] = nums[right] * nums[right];
--right;
}
}
return result;
}
```
### 复杂度分析
- 时间复杂度: O(n),其中 n 是数组 nums 的长度。
- 空间复杂度: O()
### 解题思路
数组其实是有序的, 只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端,不是最左边就是最右边,不可能是中间。
此时可以考虑双指针法了,i指向起始位置,j指向终止位置。
定义一个新数组result,和A数组一样的大小,让k指向result数组终止位置。
如果`A[i] * A[i] < A[j] * A[j]` 那么`result[k--] = A[j] * A[j];` 。
如果`A[i] * A[i] >= A[j] * A[j]` 那么`result[k--] = A[i] * A[i];` 。
如动画所示:
![](https://code-thinking.cdn.bcebos.com/gifs/977.%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%B9%B3%E6%96%B9.gif)
## 解法二: {{暴力排序}}
### 代码实现
```java
public int[] sortedSquares(int[] nums) {
int[] ans = new int[nums.length];
for (int i = 0; i < nums.length; ++i) {
ans[i] = nums[i] * nums[i];
}
Arrays.sort(ans);
return ans;
}
```
### 复杂度分析
- 时间复杂度: O(nlogn),其中 n 是数组 nums 的长度。
- 空间复杂度: O(logn)。除了存储答案的数组以外,我们需要 O(logn) 的栈空间进行排序。
### 解题思路
每个数平方之后,排个序
## 总结
前缀增量 `++left` 和后缀增量 `left++` 的区别:
- `++left`(前缀增量):
- 首先增加变量的值
- 然后返回增加后的值
- `left++`(后缀增量):
- 首先返回变量的当前值
- 然后增加变量的值