algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-08 00:43:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update

Browse Source
This commit is contained in:
youngyangyang04
2021-04-21 08:52:43 +08:00
parent 45cc93a038
commit d43a9adc44
3 changed files with 266 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -2,7 +2,7 @@
攻略里每篇文章都是公众号的文章链接，之前是为了方便，可随着star和fork的同学越来越多，发现文章链接的话没有办法及时修改题解，大家也没法参与进来，所以近期我会陆续将题解换回Markdown文件。
感谢每一位star和fork的同学，这个LeetCode-Master将越来越好，不负期待！
感谢每一位star和fork的同学，LeetCode-Master将越来越好，不负期待！
## 一些闲话：
@ -129,7 +129,7 @@
## 数组
1. [数组过于简单，但你该了解这些！](https://mp.weixin.qq.com/s/c2KABb-Qgg66HrGf8z-8Og)
1. [数组过于简单，但你该了解这些！](./problems/数组理论基础.md)
2. [数组：每次遇到二分法，都是一看就会，一写就废](https://mp.weixin.qq.com/s/fCf5QbPDtE6SSlZ1yh_q8Q)
3. [数组：就移除个元素很难么？](https://mp.weixin.qq.com/s/wj0T-Xs88_FHJFwayElQlA)
4. [数组：滑动窗口拯救了你](https://mp.weixin.qq.com/s/UrZynlqi4QpyLlLhBPglyg)

191
problems/0035.搜索插入位置.md Normal file
View File

@ -0,0 +1,191 @@
# 编号35：搜索插入位置
题目地址：https://leetcode-cn.com/problems/search-insert-position/
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0
# 思路
这道题目不难，但是为什么通过率相对来说并不高呢，我理解是大家对边界处理的判断有所失误导致的。
这道题目，要在数组中插入目标值，无非是这四种情况。
![35_搜索插入位置3](https://img-blog.csdnimg.cn/20201216232148471.png)
* 目标值在数组所有元素之前
* 目标值等于数组中某一个元素
* 目标值插入数组中的位置
* 目标值在数组所有元素之后
这四种情况确认清楚了，就可以尝试解题了。
接下来我将从暴力的解法和二分法来讲解此题，也借此好好讲一讲二分查找法。
## 暴力解法
暴力解题 不一定时间消耗就非常高，关键看实现的方式，就像是二分查找时间消耗不一定就很低，是一样的。
## 暴力解法C++代码
```
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
for (int i = 0; i < nums.size(); i++) {
// 分别处理如下三种情况
// 目标值在数组所有元素之前
// 目标值等于数组中某一个元素
// 目标值插入数组中的位置
if (nums[i] >= target) { // 一旦发现大于或者等于target的num[i]，那么i就是我们要的结果
return i;
}
}
// 目标值在数组所有元素之后的情况
return nums.size(); // 如果target是最大的，或者 nums为空，则返回nums的长度
}
};
```
时间复杂度：O(n)
时间复杂度：O(1)
效率如下：
![35_搜索插入位置](https://img-blog.csdnimg.cn/20201216232127268.png)
## 二分法
既然暴力解法的时间复杂度是O(n)，就要尝试一下使用二分查找法。
![35_搜索插入位置4](https://img-blog.csdnimg.cn/202012162326354.png)
大家注意这道题目的前提是数组是有序数组，这也是使用二分查找的基础条件。
以后大家**只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。**
同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下表可能不是唯一的。
大体讲解一下二分法的思路，这里来举一个例子，例如在这个数组中，使用二分法寻找元素为5的位置，并返回其下标。
![35_搜索插入位置5](https://img-blog.csdnimg.cn/20201216232659199.png)
二分查找涉及的很多的边界条件，逻辑比较简单，就是写不好。
相信很多同学对二分查找法中边界条件处理不好。
例如到底是 `while(left < right)` 还是 `while(left <= right)`，到底是`right = middle`呢，还是要`right = middle - 1`呢？
这里弄不清楚主要是因为**对区间的定义没有想清楚，这就是不变量**。
要在二分查找的过程中，保持不变量，这也就是**循环不变量** （感兴趣的同学可以查一查）。
## 二分法第一种写法
以这道题目来举例，以下的代码中定义 target 是在一个在左闭右闭的区间里，**也就是[left, right] （这个很重要）**。
这就决定了这个二分法的代码如何去写，大家看如下代码：
**大家要仔细看注释，思考为什么要写while(left <= right)， 为什么要写right = middle - 1**。
```
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int n = nums.size();
int left = 0;
int right = n - 1; // 定义target在左闭右闭的区间里，[left, right]
while (left <= right) { // 当left==right，区间[left, right]依然有效
int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
if (nums[middle] > target) {
right = middle - 1; // target 在左区间，所以[left, middle - 1]
} else if (nums[middle] < target) {
left = middle + 1; // target 在右区间，所以[middle + 1, right]
} else { // nums[middle] == target
return middle;
}
}
// 分别处理如下四种情况
// 目标值在数组所有元素之前 [0, -1]
// 目标值等于数组中某一个元素 return middle;
// 目标值插入数组中的位置 [left, right]，return right + 1
// 目标值在数组所有元素之后的情况 [left, right]， return right + 1
return right + 1;
}
};
```
时间复杂度：O(logn)
时间复杂度：O(1)
效率如下：
![35_搜索插入位置2](https://img-blog.csdnimg.cn/2020121623272877.png)
## 二分法第二种写法
如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) 。
那么二分法的边界处理方式则截然不同。
不变量是[left, right)的区间，如下代码可以看出是如何在循环中坚持不变量的。
**大家要仔细看注释，思考为什么要写while (left < right)， 为什么要写right = middle**。
```
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int n = nums.size();
int left = 0;
int right = n; // 定义target在左闭右开的区间里，[left, right) target
while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间
int middle = left + ((right - left) >> 1);
if (nums[middle] > target) {
right = middle; // target 在左区间，在[left, middle)中
} else if (nums[middle] < target) {
left = middle + 1; // target 在右区间，在 [middle+1, right)中
} else { // nums[middle] == target
return middle; // 数组中找到目标值的情况，直接返回下标
}
}
// 分别处理如下四种情况
// 目标值在数组所有元素之前 [0,0)
// 目标值等于数组中某一个元素 return middle
// 目标值插入数组中的位置 [left, right) ，return right 即可
// 目标值在数组所有元素之后的情况 [left, right)，return right 即可
return right;
}
};
```
时间复杂度：O(logn)
时间复杂度：O(1)
# 总结
希望通过这道题目，大家会发现平时写二分法，为什么总写不好，就是因为对区间定义不清楚。
确定要查找的区间到底是左闭右开[left, right)，还是左闭又闭[left, right]，这就是不变量。
然后在**二分查找的循环中，坚持循环不变量的原则**，很多细节问题，自然会知道如何处理了。
**循序渐进学算法，认准「代码随想录」，Carl手把手带你过关斩将！**

82
problems/数组理论基础.md
View File

@ -1,6 +1,3 @@
<p align='center'>
<img src="https://img-blog.csdnimg.cn/20201215214102642.png" width=400 >
</p>
<p align="center">
<a href="https://github.com/youngyangyang04/leetcode-master"><img src="https://img.shields.io/badge/Github-leetcode--master-lightgrey" alt=""></a>
<a href="https://img-blog.csdnimg.cn/20201115103410182.png"><img src="https://img.shields.io/badge/刷题-微信群-green" alt=""></a>
@ -48,16 +45,83 @@
**那么二维数组在内存的空间地址是连续的么？**
我们来举一个例子，例如： `int[][] rating = new int[3][4];` ， 这个二维数据在内存空间可不是一个 `3*4` 的连续地址空间
不同编程语言的内存管理是不一样的，以C++为例，在C++中二维数组是连续分布的。
看了下图，就应该明白了：
我们来做一个实验，C++测试代码如下：
```C++
void test_arr() {
int array[2][3] = {
{0, 1, 2},
{3, 4, 5}
};
cout << &array[0][0] << " " << &array[0][1] << " " << &array[0][2] << endl;
cout << &array[1][0] << " " << &array[1][1] << " " << &array[1][2] << endl;
}
int main() {
test_arr();
}
```
测试地址为
```
0x7ffee4065820 0x7ffee4065824 0x7ffee4065828
0x7ffee406582c 0x7ffee4065830 0x7ffee4065834
```
注意地址为16进制，可以看出二维数组地址是连续一条线的。
一些录友可能看不懂内存地址，我就简单介绍一下， 0x7ffee4065820 与 0x7ffee4065824 差了一个4，就是4个字节，因为这是一个int型的数组，所以两个相信数组元素地址差4个字节。
0x7ffee4065828 与 0x7ffee406582c 也是差了4个字节，在16进制里8 + 4 = c，c就是12。
如图：
![数组内存](https://img-blog.csdnimg.cn/20210310150641186.png)
**所以可以看出在C++中二维数组在地址空间上是连续的**。
像Java是没有指针的，同时也不对程序员暴漏其元素的地址，寻址操作完全交给虚拟机。
所以看不到每个元素的地址情况，这里我以Java为例，也做一个实验。
```Java
public static void test_arr() {
int[][] arr = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}, {9,9,9}};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
}
```
输出的地址为：
```
[I@7852e922
[I@4e25154f
[I@70dea4e
[I@5c647e05
```
这里的数值也是16进制，这不是真正的地址，而是经过处理过后的数值了，我们也可以看出，二维数组的每一行头结点的地址是没有规则的，更谈不上连续。
所以Java的二维数组可能是如下排列的方式：
![算法通关数组3](https://img-blog.csdnimg.cn/20201214111631844.png)
所以**二维数据在内存中不是 `3*4` 的连续地址空间，而是四条连续的地址空间组成！**
很多同学会以为二维数组在内存中是一片连续的地址，其实并不是。
这里面试中数组相关的理论知识就介绍完了。
后续我将介绍面试中数组相关的五道经典面试题目，敬请期待！
-------------------------
* 公众号：[代码随想录](https://img-blog.csdnimg.cn/20210210152223466.png)
* B站：[代码随想录](https://space.bilibili.com/525438321)
* Github：[leetcode-master](https://github.com/youngyangyang04/leetcode-master)
* 知乎：[代码随想录](https://www.zhihu.com/people/sun-xiu-yang-64)
![](https://img-blog.csdnimg.cn/20210416110157800.png)