纯小白一枚，希望和各位同学一起讨论学习，也欢迎各位帮忙指点一二。
目录：
（一）二分法
（二）移除元素
（三）有序数组的平方
（四）长度最小的子数组
(五) 螺旋矩阵
（一）二分法
关键点分为两部分：
一：left和right的关系是≤还是＜；
二：在middle对应的值＜target时，left是＝middle还是middle+1（另一种情况同理）
解决思路：
对区间的划分往往需要分类讨论，本题按照[ ]和 [ )分析：
[ a, b ]:
根据闭区间的特性，当a=b时是合法的，也就是left可以等于right；
而当middle的值小于target的大小时，重新划分的区域应当不该包括已知的middle值（这个值已经比较过了），所以left=middle+1。
[ a, b ):
根据开区间的特性，当a=b时是不合法的，也就是left只可以小于right；
而当middle的值小于target的大小时，开区间本身就表示不包含右边这个值，此时left必须等于middle，否则会露掉这个值导致结果出错。
代码：
#include <iostream>
#include <vector>
using namespace std;
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;
if (target < nums[middle])
right = middle - 1;
else if (target > nums[middle])
left = middle + 1;
else
return middle;
return -1;
}
}
};
int main() {
Solution s;
vector<int> nums = {1, 3, 5, 7, 9};
int target = 3;
cout << s.search(nums, target) << endl;
return 0;
}附：力扣相关解题代码：
35：搜索插入位置：
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
int searchInsert(vector<int> &nums, int target) {
int n = nums.size();
int l = 0, r = n - 1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (nums[mid] < target)
l = mid + 1;
else
r = mid - 1;
}
return l;
}
};
int main() {
Solution s;
vector<int> nums = {1, 3, 5, 6};
int target = 2;
cout << s.searchInsert(nums, target) << endl;
return 0;
}
34. 在排序数组中查找元素的第一个和最后一个位置
写麻了。。。去打游戏去了（目移）
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target) {
int l_first=bia(nums,target);
int r_last=bia(nums,target+1)-1;//相当于找比target大一个的开始位置的前一个，就是目标位置
if(l_first<=r_last)
return vector<int> {l_first,r_last};
return vector<int> {-1,-1};
}
int bia(vector<int> &nums,int target){
int n=nums.size()-1;
int left=0,right=n-1,mid;
while(left<=right){//首先先找第一个
mid=left+(right-left)/2;
if(nums[mid]<target){
left=mid+1;
}
else
right=mid-1;
}
return left;
}
};69 x的平方根
class Solution {
public:
int mySqrt(int x) {
int l=0,r=x;
while(l<=r){
int mid=l+(r-l)/2;
if((long)(mid*mid)<=x)//用long是因为怕超过了int的范围
l=mid+1;
else
r=mid-1;
}
return l-1;
}
};367 有效的完全平方数 同理
有个牛顿迭代法，码一下回头学
（二）移除元素
数组是连续分配的，当删除其中x值后，后续的数需要挨个往前移，添加同理。erase因此是O（n）而不是O（1）。
两种解法：两重循环暴力法和双指针法
双指针：快指针fast：指代新数组中获取的元素
慢指针low:指代这个新数组获取的元素的位置
其实是覆盖思想，当fast指向不等于x的值时，说明这是新数组需要的值，fast和low指针均向后移。相反，当fast指向x时，这不是要的值，low不动，fast向后 。
代码：
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
int removeElement(vector<int> &nums, int val) {
int fast, low = 0;
for (fast = 0; fast < nums.size(); fast++)
if (nums[fast] != val) {
nums[low++] = nums[fast];
}
return low;//不是low加一是因为最后一次循环后low自己加过一了
}
};
int main() {
Solution s;
vector<int> nums = {1, 2, 3, 4, 5};
int val = 3;
cout << s.removeElement(nums, val) << endl;
return 0;
}附：力扣相关解题代码：
844：比较含退格字符串：(*)
class Solution {
public:
bool backspaceCompare(string S, string T) {
int i = S.length() - 1, j = T.length() - 1;
int skipS = 0, skipT = 0;
while (i >= 0 || j >= 0) {
while (i >= 0) {
if (S[i] == '#') {
skipS++, i--;
} else if (skipS > 0) {
skipS--, i--;
} else {
break;
}
}
while (j >= 0) {
if (T[j] == '#') {
skipT++, j--;
} else if (skipT > 0) {
skipT--, j--;
} else {
break;
}
}
if (i >= 0 && j >= 0) {
if (S[i] != T[j]) {
return false;
}
} else {
if (i >= 0 || j >= 0) {
return false;
}
}
i--, j--;
}
return true;
}
};
（三）有序数组的平方
一、直接排序：（暴力法，O（nlogn））
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
//直接排序
vector<int> ans;
for(int num:nums){//num指代nums中每个元素
ans.push_back(num*num);//向容器里添加元素
}
sort(ans.begin(),ans.end());//头文件#include<algorithm>
return ans;
}
};二、双指针：分析数组的特性，i指针从头开始，j指针从尾开始，平方大小一定是两边大中间小。
没有说原地的话可以先构建一个数组。
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
int n=nums.size();
vector<int> ans(n);
//逆序的思想，观察数据得出
for(int i=0,j=n-1,pos=n-1;i<=j;){
if(nums[i]*nums[i]>nums[j]*nums[j]){
ans[pos]=nums[i]*nums[i];
i++;
}
else{
ans[pos]=nums[j]*nums[j];
j--;
}
pos--;
}
return ans;
}
};（四）长度最小的子数组
方法一：两层for循环暴力法，在实际使用时超时了。
方法二：采用滑动窗口的思想：用一个for循环代替两个for循环
注意：j 指针所指位置一定是终点而不是起点，否则就和暴力法一样了。
本题的关键是怎么移动起始位置，判定（当从起点到终点的和大于等于s时，说明符合题目要求，起点可以向后移）
代码：
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int result = INT_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 == INT_MAX ? 0 : result;
}
};904 水果成篮(*)
这题目贼离谱，翻译过来就是找到包含两元素的最大字串，其实就是求最大长度
class Solution {
public:
int totalFruit(vector<int>& fruits) {
int left = 0,right = 0,ans = 0;//ans记录最大长度
int ln = fruits[left],rn = fruits[right];
while(right < fruits.size()){
if(fruits[right] == rn || fruits[right] == ln){
ans = max(ans,right + 1 - left);
right++;
}else{
left = right - 1;//先回退到前一个
ln = fruits[left];
while(left >= 1 && fruits[left - 1] == ln) left--;//如果出现0222333这种，回退到最开始的2就行了
rn = fruits[right];
ans = max(ans,right + 1 - left);
}
}
return ans;
}
};76最小覆盖字串(难*)
class Solution {
public:
string minWindow(string s, string t) {
unordered_map<char, int> tmap, smap;
int left = 0, correct = 0;//correct用来记录s中包含的t的个数
string res = s + "initialize a max string";
// 对于t制作字符出现数的字典
for (auto item : t)
++tmap[item];
for (int right = 0; right < s.size(); ++right) {
// smap维护的是当前窗口内的字符出现数的字典
++smap[s[right]];
// 当前right对应s的字符是在t中出现的，并且数量上还没有达到冗余，是一次有效添加
if (tmap[s[right]] >= smap[s[right]])
++correct;
// 字符串最短是空串 && 如果left对应的字符是冗余，那么进行右移删除
while (left < right && smap[s[left]] > tmap[s[left]])
--smap[s[left++]];
if (correct == t.size()){
// 窗口内已经满足t串的所有字符
if (right - left + 1 < res.size())
res = s.substr(left, right - left + 1);//截取
}
}
return res == s + "initialize a max string" ? "" : res;
}
};（五）螺旋矩阵(*)
本题的关键是如何确立矩阵边界问题
如果都是左闭右闭，显然在计算过程中会多算重复的值，如果都是按照左闭右开，就不会重复计算边结点。
切记一定不能一会左闭右闭，一会左闭右开。
注意一下怎么初始化二维数组
class Solution {
public:
vector<vector<int>> generateMatrix(int n) {
vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
int count = 1; // 用来给矩阵中每一个空格赋值
int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
int i,j;
while (loop --) {
i = startx;
j = starty;
// 下面开始的四个for就是模拟转了一圈
// 模拟填充上行从左到右(左闭右开)
for (j = starty; j < n - offset; j++) {
res[startx][j] = count++;
}
// 模拟填充右列从上到下(左闭右开)
for (i = startx; i < n - offset; i++) {
res[i][j] = count++;
}
// 模拟填充下行从右到左(左闭右开)
for (; j > starty; j--) {
res[i][j] = count++;
}
// 模拟填充左列从下到上(左闭右开)
for (; i > startx; i--) {
res[i][j] = count++;
}
// 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
startx++;
starty++;
// offset 控制每一圈里每一条边遍历的长度
offset += 1;
}
// 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
if (n % 2) {
res[mid][mid] = count;
}
return res;
}
};总结：
感觉最小覆盖字串那里学的不好，下个章节结束回来捋一下。
367
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
