语言细节
+语言细节
vector的长度：
- C++：nums.size()
- Python：len(nums)
- GO：len(nums)
构造vector:
+-
+
- C++：vector result(长度，元素) +
- Python：res = [float('inf')] * len(nums) +
- GO：:=make([]int，n) +
for循环：
- C++：条件小括号+循环体中括号 @@ -322,6 +330,66 @@
- 窗口内是什么？ +
- 如何移动窗口的起始位置？ +
- 如何移动窗口的结束位置？ +
- C++：nums.size()
- Python：len(nums)
- GO：len(nums)
- C++：条件小括号+循环体中括号
- Python：冒号且不需要小括号包条件
- GO：循环体中括号，条件按照C++写但是不需要小括号
- 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
- 慢指针：指向更新 新数组下标的位置
- C++：nums.size()
- Python：len(nums)
- GO：len(nums)
- C++：vector result(长度，元素)
- Python：res = [float('inf')] * len(nums)
- GO：:=make([]int，n)
- C++：条件小括号+循环体中括号
- Python：冒号且不需要小括号包条件
- GO：循环体中括号，条件按照C++写但是不需要小括号
- 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
- 慢指针：指向更新 新数组下标的位置
- 窗口内是什么？
- 如何移动窗口的起始位置？
- 如何移动窗口的结束位置？
- C++：nums.size()
- Python：len(nums)
- GO：len(nums)
- C++：vector result(长度，元素) +
- Python：res = [float('inf')] * len(nums) +
- GO：:=make([]int，n) +
- C++：条件小括号+循环体中括号 @@ -2506,6 +2512,66 @@ alt="编译错误" />
- 窗口内是什么？ +
- 如何移动窗口的起始位置？ +
- 如何移动窗口的结束位置？ +
思路
1 | |
GO版本：
1 | |
有序数组的平方
+https://leetcode.cn/problems/squares-of-a-sorted-array/
+题目描述
+示例 1：
+1 | |
示例 2：
+1 | |
思路
+双指针法，首尾遍历比较并存储
+
+
+1 | |
Python:
+1 | |
GO:
+1 | |
长度最小的子数组
+https://leetcode.cn/problems/minimum-size-subarray-sum/description/
+题目描述
+给定一个含有 n 个正整数的数组和一个正整数
+target 。
找出该数组中满足其总和大于等于 target 的长度最小的
+连续子数组
+[numsl, numsl+1, ..., numsr-1, numsr]
+，并返回其长度。如果不存在符合条件的子数组，返回
+0 。
示例 1：
+1 | |
示例 2：
+1 | |
示例 3：
+1 | |
思路
+滑动窗口法
+
滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动本题中实现滑动窗口，主要确定如下三点：
+-
+
窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
+1 | |
螺旋矩阵
+https://leetcode.cn/problems/spiral-matrix-ii/
+题目描述：
+
给你一个正整数 n ，生成一个包含 1 到
+n2 所有元素，且元素按顺时针顺序螺旋排列的
+n x n 正方形矩阵 matrix
1 | |
示例 2：
+1 | |
思路：
+大模拟循环遍历
+1 | |
哈希表
链表
二叉树
diff --git a/index.html b/index.html index 832a7a8..9baf9d8 100644 --- a/index.html +++ b/index.html @@ -281,7 +281,7 @@
- 语言细节 vector的长度： C++：nums.size() Python：len(nums) GO：len(nums) for循环： C++：条件小括号+循环体中括号 Python：冒号且不需要小括号包条件 GO：循环体中括号，条件按照C++写但是不需要小括号 数组 二分查找 题目描述 链接：https://leetcode.cn/problems/binary-search/des
+ 语言细节 vector的长度： C++：nums.size() Python：len(nums) GO：len(nums) 构造vector: C++：vector result(长度，元素) Python：res = [float('inf')] * len(nums) GO：:=make([]int，n) for循环： C++：条件小括号+循环体中括号 Python：冒号且不需要小
diff --git a/local-search.xml b/local-search.xml
index 39ce6d8..0a93ae3 100644
--- a/local-search.xml
+++ b/local-search.xml
@@ -35,7 +35,7 @@
/2024/01/01/leetcode/
- 语言细节
vector的长度：
for循环：
数组
二分查找
题目描述
链接：https://leetcode.cn/problems/binary-search/description/
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回-1。
示例 1:
1
2
3
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
1
2
3
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
思路
题目表示的是有序数组，而且题目没有重复元素。在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution:
def search(self, nums: List[int], target: int) -> int:
left, right = 0, len(nums) - 1 # 定义target在左闭右闭的区间里，[left, right]
while left <= right:
middle = left + (right - left) // 2
if nums[middle] > target:
right = middle - 1 # target在左区间，所以[left, middle - 1]
elif nums[middle] < target:
left = middle + 1 # target在右区间，所以[middle + 1, right]
else:
return middle # 数组中找到目标值，直接返回下标
return -1 # 未找到目标值
注意这里给出的题解法：当left <= right的时候，以下的条件中全部都不取到等号nums[middle] > target nums[middle] < target
需要注意的是：right=nums.size()-1
C++版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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)/2; 这样写会溢出
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;
}
};
Go版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func search(nums []int, target int) int {
right:=len(nums)-1
left:=0
for left<=right{
middle:= left+(right-left)/2
if nums[middle]<target{
left = middle+1
}else if nums[middle]>target{
right = middle-1
}else{
return middle
}
}
return -1
}
移除元素
https://leetcode.cn/problems/remove-element/description/
题目描述
示例 1：
1
2
3
输入：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：
1
2
3
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,3,0,4]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
思路
双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
C++版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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];
slowindex++;
}
}
return slowindex;
}
};
python版本
1
2
3
4
5
6
7
8
9
10
class Solution(object):
def removeElement(self, nums, val):
slowindex=0
fastindex=0
while fastindex<len(nums):
if val!=nums[fastindex]:
nums[slowindex]=nums[fastindex]
slowindex = slowindex+1
fastindex+=1
return slowindex
GO版本：
1
2
3
4
5
6
7
8
9
10
func removeElement(nums []int, val int) int {
slow:=0
for i:=0;i<len(nums);i++{
if nums[i]!=val{
nums[slow]=nums[i]
slow++
}
}
return slow
}
哈希表
链表
二叉树
回溯算法
贪心算法
动态规划
]]>语言细节
vector的长度：
构造vector:
for循环：
数组
二分查找
题目描述
链接：https://leetcode.cn/problems/binary-search/description/
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回-1。
示例 1:
1
2
3
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
1
2
3
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
思路
题目表示的是有序数组，而且题目没有重复元素。在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution:
def search(self, nums: List[int], target: int) -> int:
left, right = 0, len(nums) - 1 # 定义target在左闭右闭的区间里，[left, right]
while left <= right:
middle = left + (right - left) // 2
if nums[middle] > target:
right = middle - 1 # target在左区间，所以[left, middle - 1]
elif nums[middle] < target:
left = middle + 1 # target在右区间，所以[middle + 1, right]
else:
return middle # 数组中找到目标值，直接返回下标
return -1 # 未找到目标值
注意这里给出的题解法：当left <= right的时候，以下的条件中全部都不取到等号nums[middle] > target nums[middle] < target
需要注意的是：right=nums.size()-1
C++版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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)/2; 这样写会溢出
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;
}
};
Go版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func search(nums []int, target int) int {
right:=len(nums)-1
left:=0
for left<=right{
middle:= left+(right-left)/2
if nums[middle]<target{
left = middle+1
}else if nums[middle]>target{
right = middle-1
}else{
return middle
}
}
return -1
}
移除元素
https://leetcode.cn/problems/remove-element/description/
题目描述
示例 1：
1
2
3
输入：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：
1
2
3
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,3,0,4]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
思路
双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
C++版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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];
slowindex++;
}
}
return slowindex;
}
};
python版本
1
2
3
4
5
6
7
8
9
10
class Solution(object):
def removeElement(self, nums, val):
slowindex=0
fastindex=0
while fastindex<len(nums):
if val!=nums[fastindex]:
nums[slowindex]=nums[fastindex]
slowindex = slowindex+1
fastindex+=1
return slowindex
GO版本：
1
2
3
4
5
6
7
8
9
10
func removeElement(nums []int, val int) int {
slow:=0
for i:=0;i<len(nums);i++{
if nums[i]!=val{
nums[slow]=nums[i]
slow++
}
}
return slow
}
有序数组的平方
https://leetcode.cn/problems/squares-of-a-sorted-array/
题目描述
示例 1：
1
2
3
4
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：
1
2
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
思路
双指针法，首尾遍历比较并存储
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
vector<int> result(nums.size(),0);
int j = nums.size()-1;
int k =j;
for(int i = 0 ;i<=j;)
{
if(nums[i]*nums[i]>nums[j]*nums[j]){
result[k--]= nums[i]*nums[i];
i++;
}else{
result[k--]= nums[j]*nums[j];
j--;
}
}
return result;
}
};
Python:
1
2
3
4
5
6
7
8
9
10
11
12
class Solution(object):
def sortedSquares(self, nums):
l, r, i = 0, len(nums)-1, len(nums)-1
res = [float('inf')] * len(nums) # 需要提前定义列表，存放结果
while l<=r :
if nums[l]*nums[l] < nums[r]*nums[r] :
res[i--]=nums[r]*nums[r]
r--
else:
res[i--]=nums[l]*nums[l]
l++
return
GO:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func sortedSquares(nums []int) []int {
n := len(nums)
i, j, k := 0, n-1, n-1
ans := make([]int, n)
for i <= j {
lm, rm := nums[i]*nums[i], nums[j]*nums[j]
if lm > rm {
ans[k] = lm
i++
} else {
ans[k] = rm
j--
}
k--
}
return ans
}
长度最小的子数组
https://leetcode.cn/problems/minimum-size-subarray-sum/description/
题目描述
给定一个含有 n 个正整数的数组和一个正整数target 。
找出该数组中满足其总和大于等于 target 的长度最小的连续子数组[numsl, numsl+1, ..., numsr-1, numsr]，并返回其长度。如果不存在符合条件的子数组，返回0 。
示例 1：
1
2
3
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：
1
2
输入：target = 4, nums = [1,4,4]
输出：1
示例 3：
1
2
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0
思路
滑动窗口法
滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动本题中实现滑动窗口，主要确定如下三点：
窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int result = INT32_MAX;
int sum = 0; // 滑动窗口数值之和
int i = 0; // 滑动窗口起始位置
int subLength = 0; // 滑动窗口的长度
for (int j = 0; j < nums.size(); j++) {
sum += nums[j];
// 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
while (sum >= s) {
subLength = (j - i + 1); // 取子序列的长度
result = result < subLength ? result : subLength;
sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
}
}
// 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
return result == INT32_MAX ? 0 : result;
}
};
螺旋矩阵
https://leetcode.cn/problems/spiral-matrix-ii/
题目描述：
给你一个正整数 n ，生成一个包含 1 到n2 所有元素，且元素按顺时针顺序螺旋排列的n x n 正方形矩阵 matrix
1
2
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
示例 2：
1
2
输入：n = 1
输出：[[1]]
思路：
大模拟循环遍历
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Solution {
public:
vector<vector<int>> generateMatrix(int n) {
vector<vector<int>> result(n, vector<int>(n,0));
int is=0,ie=n-1,js=0,je=n-1;
int k = 1;
while(is<=ie&&js<=je){
for(int j=js;j<=je;j++)
{
result[is][j] = k++;
}
is++;
for(int i =is;i<=ie;i++)
{
result[i][je] = k++;
}
je--;
for(int j=je;j>=js;j--)
{
result[ie][j] = k++;
}
ie--;
for(int i=ie;i>=is;i--)
{
result[i][js] = k++;
}
js++;
}
return result;
}
};
哈希表
链表
二叉树
回溯算法
贪心算法
动态规划
]]>
diff --git a/search.xml b/search.xml
index 42bb3db..647fd4b 100644
--- a/search.xml
+++ b/search.xml
@@ -2449,13 +2449,19 @@ alt="编译错误" />
【算法题】LeetCode算法汇总
/2024/01/01/leetcode/
-语言细节
+语言细节
vector的长度：
+构造vector:
+
+
for循环：
class Solution(object):
def removeElement(self, nums, val):
slowindex=0
fastindex=0
while fastindex<len(nums):
if val!=nums[fastindex]:
nums[slowindex]=nums[fastindex]
slowindex = slowindex+1
fastindex+=1
return slowindex
GO版本：
func removeElement(nums []int, val int) int {
slow:=0
for i:=0;i<len(nums);i++{
if nums[i]!=val{
nums[slow]=nums[i]
slow++
}
}
return slow
}
+有序数组的平方
+https://leetcode.cn/problems/squares-of-a-sorted-array/
+题目描述
+示例 1：
+输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
+示例 2：
+输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
+思路
+双指针法，首尾遍历比较并存储
+
+![]()
+
+
+class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
vector<int> result(nums.size(),0);
int j = nums.size()-1;
int k =j;
for(int i = 0 ;i<=j;)
{
if(nums[i]*nums[i]>nums[j]*nums[j]){
result[k--]= nums[i]*nums[i];
i++;
}else{
result[k--]= nums[j]*nums[j];
j--;
}
}
return result;
}
};
+Python:
+class Solution(object):
def sortedSquares(self, nums):
l, r, i = 0, len(nums)-1, len(nums)-1
res = [float('inf')] * len(nums) # 需要提前定义列表，存放结果
while l<=r :
if nums[l]*nums[l] < nums[r]*nums[r] :
res[i--]=nums[r]*nums[r]
r--
else:
res[i--]=nums[l]*nums[l]
l++
return
+GO:
+func sortedSquares(nums []int) []int {
n := len(nums)
i, j, k := 0, n-1, n-1
ans := make([]int, n)
for i <= j {
lm, rm := nums[i]*nums[i], nums[j]*nums[j]
if lm > rm {
ans[k] = lm
i++
} else {
ans[k] = rm
j--
}
k--
}
return ans
}
+长度最小的子数组
+https://leetcode.cn/problems/minimum-size-subarray-sum/description/
+题目描述
+给定一个含有 n 个正整数的数组和一个正整数
+target 。
+找出该数组中满足其总和大于等于 target 的长度最小的
+连续子数组
+[numsl, numsl+1, ..., numsr-1, numsr]
+，并返回其长度。如果不存在符合条件的子数组，返回
+0 。
+示例 1：
+输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
+示例 2：
+输入：target = 4, nums = [1,4,4]
输出：1
+示例 3：
+输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0
+思路
+滑动窗口法
+
+滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动本题中实现滑动窗口，主要确定如下三点：
+
+
+窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
+class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int result = INT32_MAX;
int sum = 0; // 滑动窗口数值之和
int i = 0; // 滑动窗口起始位置
int subLength = 0; // 滑动窗口的长度
for (int j = 0; j < nums.size(); j++) {
sum += nums[j];
// 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
while (sum >= s) {
subLength = (j - i + 1); // 取子序列的长度
result = result < subLength ? result : subLength;
sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
}
}
// 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
return result == INT32_MAX ? 0 : result;
}
};
+螺旋矩阵
+https://leetcode.cn/problems/spiral-matrix-ii/
+题目描述：
+
+给你一个正整数 n ，生成一个包含 1 到
+n2 所有元素，且元素按顺时针顺序螺旋排列的
+n x n 正方形矩阵 matrix
+输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
+示例 2：
+输入：n = 1
输出：[[1]]
+思路：
+大模拟循环遍历
+class Solution {
public:
vector<vector<int>> generateMatrix(int n) {
vector<vector<int>> result(n, vector<int>(n,0));
int is=0,ie=n-1,js=0,je=n-1;
int k = 1;
while(is<=ie&&js<=je){
for(int j=js;j<=je;j++)
{
result[is][j] = k++;
}
is++;
for(int i =is;i<=ie;i++)
{
result[i][je] = k++;
}
je--;
for(int j=je;j>=js;j--)
{
result[ie][j] = k++;
}
ie--;
for(int i=ie;i>=is;i--)
{
result[i][js] = k++;
}
js++;
}
return result;
}
};
哈希表
链表
二叉树
语言细节
vector的长度：
for循环：
数组
二分查找
题目描述
链接：https://leetcode.cn/problems/binary-search/description/
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回-1。
示例 1:
1 | |
示例 2:
1 | |
思路
题目表示的是有序数组，而且题目没有重复元素。在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则
1 | |
注意这里给出的题解法：当left <= right的时候，以下的条件中全部都不取到等号nums[middle] > target nums[middle] < target
需要注意的是：right=nums.size()-1
C++版本
1 | |
Go版本
1 | |
移除元素
https://leetcode.cn/problems/remove-element/description/
题目描述
示例 1：
1 | |
示例 2：
1 | |
思路
双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
C++版本
1 | |
python版本
1 | |
GO版本：
1 | |
哈希表
链表
二叉树
回溯算法
贪心算法
动态规划
]]>语言细节
vector的长度：
构造vector:
for循环：
数组
二分查找
题目描述
链接：https://leetcode.cn/problems/binary-search/description/
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回-1。
示例 1:
1 | |
示例 2:
1 | |
思路
题目表示的是有序数组，而且题目没有重复元素。在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则
1 | |
注意这里给出的题解法：当left <= right的时候，以下的条件中全部都不取到等号nums[middle] > target nums[middle] < target
需要注意的是：right=nums.size()-1
C++版本
1 | |
Go版本
1 | |
移除元素
https://leetcode.cn/problems/remove-element/description/
题目描述
示例 1：
1 | |
示例 2：
1 | |
思路
双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
C++版本
1 | |
python版本
1 | |
GO版本：
1 | |
有序数组的平方
https://leetcode.cn/problems/squares-of-a-sorted-array/
题目描述
示例 1：
1 | |
示例 2：
1 | |
思路
双指针法，首尾遍历比较并存储
1 | |
Python:
1 | |
GO:
1 | |
长度最小的子数组
https://leetcode.cn/problems/minimum-size-subarray-sum/description/
题目描述
给定一个含有 n 个正整数的数组和一个正整数target 。
找出该数组中满足其总和大于等于 target 的长度最小的连续子数组[numsl, numsl+1, ..., numsr-1, numsr]，并返回其长度。如果不存在符合条件的子数组，返回0 。
示例 1：
1 | |
示例 2：
1 | |
示例 3：
1 | |
思路
滑动窗口法
滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动本题中实现滑动窗口，主要确定如下三点：
窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
1 | |
螺旋矩阵
https://leetcode.cn/problems/spiral-matrix-ii/
题目描述：
给你一个正整数 n ，生成一个包含 1 到n2 所有元素，且元素按顺时针顺序螺旋排列的n x n 正方形矩阵 matrix
1 | |
示例 2：
1 | |
思路：
大模拟循环遍历
1 | |
哈希表
链表
二叉树
回溯算法
贪心算法
动态规划
]]>语言细节
+语言细节
vector的长度：
构造vector:
+-
+
for循环：
|
GO版本：
|
有序数组的平方
+https://leetcode.cn/problems/squares-of-a-sorted-array/
+题目描述
+示例 1：
+ |
示例 2：
+ |
思路
+双指针法，首尾遍历比较并存储
+ |
Python:
+ |
GO:
+ |
长度最小的子数组
+https://leetcode.cn/problems/minimum-size-subarray-sum/description/
+题目描述
+给定一个含有 n 个正整数的数组和一个正整数
+target 。
找出该数组中满足其总和大于等于 target 的长度最小的
+连续子数组
+[numsl, numsl+1, ..., numsr-1, numsr]
+，并返回其长度。如果不存在符合条件的子数组，返回
+0 。
示例 1：
+ |
示例 2：
+ |
示例 3：
+ |
思路
+滑动窗口法
+
滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动本题中实现滑动窗口，主要确定如下三点：
+-
+
窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
+ |
螺旋矩阵
+https://leetcode.cn/problems/spiral-matrix-ii/
+题目描述：
+
给你一个正整数 n ，生成一个包含 1 到
+n2 所有元素，且元素按顺时针顺序螺旋排列的
+n x n 正方形矩阵 matrix
|
示例 2：
+ |
思路：
+大模拟循环遍历
+ |