代码随想录算法训练营第一天|数组part01|704.35.34.27
2023/7/26 任务
数组理论基础，704. 二分查找，27. 移除元素
数组理论基础
- 数组是存放在连续内存空间上的相同类型数据的集合。
- 数组的元素是不能删的，只能覆盖。
- 在C++中二维数组在地址空间上是连续的。Java中可能是这样的：
704.二分查找 ⭐
左闭右闭/左闭右开
题目链接
文章讲解
视频讲解
二分法前提条件：
数组为有序数组
数组中无重复元素
易混点：
是right = nums.length - 1呢，还是right = nums.length，是 while(left < right) 还是 while(left <= right)，是right = middle呢，还是right = middle - 1？
在循环中要坚持根据查找区间的定义（不变量）来做边界处理
注意辨别两种的区别
（版本一）左闭右闭区间 [left, right]
class Solution {
public int search(int[] nums, int target) {
// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
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)
left = mid + 1;
else if (nums[mid] > target)
right = mid - 1;
}
return -1;
}
}
时间复杂度：O(log n)
空间复杂度：O(1)
（版本二）左闭右开区间 [left, right)
- right = nums.length
- while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
- if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]
class Solution {
public int search(int[] nums, int target) {
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)
left = mid + 1;
else if (nums[mid] > target)
right = mid;
}
return -1;
}
}
时间复杂度：O(log n)
空间复杂度：O(1)
相关题目
35.搜索插入位置
暴力/二分法
题目链接
文章讲解
（解法一）暴力法
class Solution {
public int searchInsert(int[] nums, int target) {
int i = 0;
for (; i < nums.length; i++) {
if (nums[i] >= target) {
break;
}
}
return i;
}
}
时间复杂度：O(n)
空间复杂度：O(1)
（解法二）二分法
相比704题，只有最后一行代码不同。
class Solution {
public int searchInsert(int[] nums, int target) {
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) {
right = mid - 1;
} else if (nums[mid] < target) {
left = mid + 1;
}
}
return right + 1;
}
}
时间复杂度：O(log n)
空间复杂度：O(1)
34.在排序数组中查找元素的第一个和最后一个位置 ⭐
题目链接
文章讲解
寻找target在数组里的左右边界，有如下三种情况：
- 情况一：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}
（解法一）
两个二分，分别寻找左右边界。
注意：计算出来的右边界是不包含target的右边界，左边界同理。
class Solution {
public int[] searchRange(int[] nums, int target) {
int rightBorder = searchRightBorder(nums, target);
int leftBorder = searchLeftBorder(nums, target);
// 情况一
if (leftBorder == -2 || rightBorder == -2) {
return new int[]{-1, -1};
}
// 情况三
else if (rightBorder - leftBorder > 1) {
return new int[]{leftBorder + 1, rightBorder - 1};
}
// 情况二
return new int[]{-1, -1};
}
public int searchRightBorder(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int rightBorder = -2;
while (left <= right) {
int mid = left + ((right - left) >> 1);
if (nums[mid] > target) {
right = mid - 1;
} else {
left = mid + 1;
rightBorder = left;
}
}
return rightBorder;
}
public int searchLeftBorder(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int leftBorder = -2;
while (left <= right) {
int mid = left + ((right - left) >> 1);
if (nums[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
leftBorder = right;
}
}
return leftBorder;
}
}
（解法二）
// 1、首先，在 nums 数组中二分查找 target；
// 2、如果二分查找失败，则 binarySearch 返回 -1，表明 nums 中没有 target。此时，searchRange 直接返回 {-1, -1}；
// 3、如果二分查找成功，则 binarySearch 返回 nums 中值为 target 的一个下标。然后，通过左右滑动指针，来找到符合题意的区间
class Solution {
public int[] searchRange(int[] nums, int target) {
int index = binarySearch(nums, target); // 二分查找
if (index == -1) { // nums 中不存在 target，直接返回 {-1, -1}
return new int[] {-1, -1}; // 匿名数组
}
// nums 中存在 targe，则左右滑动指针，来找到符合题意的区间
int left = index;
int right = index;
// 向左滑动，找左边界
while (left - 1 >= 0 && nums[left - 1] == target) { // 防止数组越界。逻辑短路，两个条件顺序不能换
left--;
}
// 向右滑动，找右边界
while (right + 1 < nums.length && nums[right + 1] == target) { // 防止数组越界。
right++;
}
return new int[] {left, right};
}
/**
* 二分查找
*/
public int binarySearch(int[] nums, int target) {
int left = 0;
int right = nums.length - 1; // 不变量：左闭右闭区间
while (left <= right) { // 不变量：左闭右闭区间
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
return mid;
} else if (nums[mid] < target) {
left = mid + 1;
} else {
right = mid - 1; // 不变量：左闭右闭区间
}
}
return -1; // 不存在
}
}
27. 移除元素 ⭐
暴力/双指针法
题目链接
文章讲解
视频讲解
（解法一）暴力解法
两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组。
class Solution {
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; j < len - 1; j++) {
nums[j] = nums[j + 1];
}
i--;
len--;
}
}
return len;
}
}
时间复杂度：O(n^2)
空间复杂度：O(1)
（解法二）双指针法
双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
慢指针：指向更新 新数组下标的位置
public int removeElement(int[] nums, int val) {
int slow = 0;
for (int fast = 0; fast < nums.length; fast++) {
if (nums[fast] != val) {
nums[slow++] = nums[fast];
}
}
return slow;
}
时间复杂度：O(n)
空间复杂度：O(1)