温习数据结构与算法，准备一些比赛，为了学业和就业，以及提升自己的编程能力，将系统的刷刷算法，入手c++跟着carl，leetcode刷题笔记将持续更新…
数组
704. 二分查找
有序数组中无重复元素
class Solution {
public:
int search(vector<int>& nums, int target) {
int l=0;
int r=nums.size()-1;
while(l<=r){
int m=(l+r)/2; //换成 m=l+(r-l)/2防止溢出
if(nums[m]>target){
r=m-1;
}else if(nums[m]<target){
l=m+1;
}else{
return m;
}
}
return -1;
}
};
27. 移除元素
【法一】vector
erase(参数为迭代器)，一次遍历
注意：删除元素，后面元素相当于前移，下标记得-1
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
for(int i=0;i<nums.size();i++){
if(nums[i]==val){
nums.erase(nums.begin()+i);
i--;
}
}
return nums.size();
}
};
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
for (auto it = nums.begin(); it != nums.end(); it++){
if(*it==val){
nums.erase(it);
it--;
}
}
return nums.size();
}
};
【法二】数组
数组的元素是不能删的，只能覆盖。要求新数组大小，所以要把目标值移动到最后，两层for循环优化就是双指针啦
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];
}
}
return slowIndex;
}
};
977.有序数组的平方
sort函数
（1）第一个参数first：是要排序的数组的起始地址。
（2）第二个参数last：是结束的地址（最后一个数据的后一个数据的地址）
（3）第三个参数comp是排序的方法：可以是从升序也可是降序。如果第三个参数不写，则默认的排序方法是从小到大排序。
对数组A的0~n-1元素进行升序排序，sort(A,A+n)；
对于vector，sort(v.begin(),v.end())。
【法一】暴力排序
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
for(int i=0;i<nums.size();i++){
nums[i]*=nums[i];
}
sort(nums.begin(),nums.end());
return nums;
}
};
【法二】双指针
数组其实是有序的， 只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
此时可以考虑双指针法了，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]; 。
class Solution {
public:
vector<int> sortedSquares(vector<int>& A) {
int k = A.size() - 1;
vector<int> result(A.size(), 0);
for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
if (A[i] * A[i] < A[j] * A[j]) {
result[k--] = A[j] * A[j];
j--;
}
else {
result[k--] = A[i] * A[i];
i++;
}
}
return result;
}
};
209.长度最小的子数组
力扣题目链接 读题！读题！读题！
【法一】暴力，保存满足条件的最大子集长
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int n = nums.size();
if (n == 0) {
return 0;
}
int ans = INT_MAX;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = i; j < n; j++) {
sum += nums[j];
if (sum >= s) {
ans = min(ans, j - i + 1);
break;
}
}
}
return ans == INT_MAX ? 0 : ans;
}
};
【法二】双指针
可以看成滑动窗口，不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
窗口就是 满足其和 ≥ s 的长度最小的连续 子数组。
窗口的起始位置如何移动：如果当前窗口的值大于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;
}
};
【法三】前缀和 + 二分查找
因为这道题保证了数组中每个元素都为正，所以前缀和一定是递增的，这一点保证了二分的正确性。如果题目没有说明数组中每个元素都为正，这里就不能使用二分来查找这个位置了。
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums) {
int n = nums.size();
if (n == 0) {
return 0;
}
int ans = INT_MAX;
vector<int> sums(n + 1, 0); //定义前缀和数组，大小n+1，全0
// sums[1] = A[0] 前 1 个元素的前缀和为 A[0]
for (int i = 1; i <= n; i++) {
sums[i] = sums[i - 1] + nums[i - 1];
}
for (int i = 1; i <= n; i++) {
int target = s + sums[i - 1];
auto bound = lower_bound(sums.begin(), sums.end(), target);//lower_bound()在 [first, last) 区域内查找不小于 target 的元素
if (bound != sums.end()) {
ans = min(ans, static_cast<int>((bound - sums.begin()) - (i - 1)));
}
}
return ans == INT_MAX ? 0 : ans;
}
};
//在 [first, last) 区域内查找不小于 val 的元素
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,
const T& val);
//查找[first, last)区域中第一个大于 val 的元素。
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last,
const T& val);
//在 [first, last) 区域内查找第一个不符合 comp 规则的元素
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,
const T& val, Compare comp);
//找到 [first, last) 范围内所有等于 val 的元素
pair<ForwardIterator,ForwardIterator> equal_range (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);
//查找 [first, last) 区域内是否包含 val
bool binary_search (ForwardIterator first, ForwardIterator last,
const T& val);
//根据 comp 指定的规则，查找 [first, last) 区域内是否包含 val
bool binary_search (ForwardIterator first, ForwardIterator last,
const T& val, Compare comp);
59.螺旋矩阵II
没算法，读懂题画一画，模拟过程
class Solution {
public:
vector<vector<int>> generateMatrix(int n) {
int num = 1;
int left = 0, top = 0, right = n - 1, bottom = n - 1;
//初始化二维数组
vector<vector<int>> res(n,vector<int>(n));
while (num <= n*n ) {
//left to right
for (int i = left; i <= right; ++i) res[top][i] = num++;
++top;
//top to bottom
for (int i = top; i <= bottom; ++i) res[i][right] = num++;
--right;
//right to left
for (int i = right; i >= left; --i) res[bottom][i] = num++;
--bottom;
//bottom to top
for (int i = bottom; i >= top; --i) res[i][left] = num++;
++left;
}
return res;
}
};
3780
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
