本文记录的是刷题过程中的重要概念和笔记。如有侵权,请联系删除。
目录
- 数组基础知识
- 四大方法
- -------------------------------------------------------------
- 704. 二分查找 *
- 相关题目:69.x 的平方根
- -------------------------------------------------------------
- 27. 移除元素 *
- -------------------------------------------------------------
- 977.有序数组的平方
- -------------------------------------------------------------
- 209.长度最小的子数组 *
- -------------------------------------------------------------
- 59.螺旋矩阵 *
数组基础知识
使用C++的话,要注意vector 和 array的区别
- vector的底层实现是array,严格来讲vector是容器,不是数组。
- 数组的元素是不能删的,只能覆盖。
四大方法
- 二分法查找
- 双指针法
- 双指针变形—滑动窗口
- 模拟行为
-------------------------------------------------------------
704. 二分查找 *
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
123
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
123
提示:
- 你可以假设 nums 中的所有元素是不重复的。
- n 将在 [1, 10000]之间。
- nums 的每个元素都将在 [-9999, 9999]之间。
思路
对区间的定义没有想清楚,区间的定义就是不变量。
== 二分法第二种写法[left, right) ==
时间复杂度:O(log n)
注意如下两点:
- while (left < right),这里使用 < ,因为left == right在区间[left, right)是没有意义的
- [left, mid) 与 [mid+1,right)
代码如下:(详细注释)
// 版本二
class Solution {
public:
int search(vector<int>& nums, int target) {
int left = 0;
**int right = nums.size();** // 定义target在左闭右开的区间里,即:[left, right)
while (left < right) { // 因为left == right的时候,在[left, right)是无效的空间,所以使用 <
**int middle = left + ((right - left) >> 1); // 防止溢出,也可以写为int mid=left/2+right/2;**
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; // 数组中找到目标值,直接返回下标
}
}
// 未找到目标值
return -1;
}
};
优先级:
相关题目:69.x 的平方根
方法一:二分查找法
class Solution {
public:
int mySqrt(int x) {
int left = 0;
int right = x;
~~// int ans = 0;~~
while(left < right){
int mid = left + (right - left) / 2;
**long long res = (long long)mid * mid;
//2^31-1=4 byte,有符号需要8 byte,至少需要用到long**
if(res == x){
return mid;
} else if(res > x){
right = mid;
} else {
~~// ans = mid;~~
left = mid + 1;
}
}
// 最后的left可能越过x的界也可能没有,需要判断
if((long long)left*left > x) return left - 1;
else return left;
}
};
- 时间复杂度: O ( log n ) O(\log n) O(logn)
- 空间复杂度: O ( 1 ) O(1) O(1)
方法三:牛顿迭代法
-------------------------------------------------------------
27. 移除元素 *
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以**「引用」**方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
暴力解法
== 双指针法 ==
双指针法(快慢指针法): 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
- 快指针:寻找新数组的元素 ,新数组就是不含有目标元素的数组
- 慢指针:指向更新 新数组下标的位置
双指针法(快慢指针法)在数组和链表的操作中是非常常见的,很多考察数组、链表、字符串等操作的面试题,都使用双指针法。
方法一:未改变相对位置
// 时间复杂度:O(n)
// 空间复杂度:O(1)
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;
}
};
方法二:相向双指针方法(复习)
基于元素顺序可以改变的题目描述改变了元素相对位置,确保了移动最少元素
/**
* 相向双指针方法,基于元素顺序可以改变的题目描述改变了元素相对位置,确保了移动最少元素
* 时间复杂度:O(n)
* 空间复杂度:O(1)
*/
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int leftIndex = 0;
int rightIndex = nums.size() - 1;
while (leftIndex <= rightIndex) {
// 找左边等于val的元素
while (leftIndex <= rightIndex && nums[leftIndex] != val){
++leftIndex;
}
// 找右边不等于val的元素
while (leftIndex <= rightIndex && nums[rightIndex] == val) {
-- rightIndex;
}
// 将右边不等于val的元素覆盖左边等于val的元素
if (leftIndex < rightIndex) {
nums[leftIndex++] = nums[rightIndex--];
}
}
return leftIndex; // leftIndex一定指向了最终数组末尾的下一个元素
}
};
-------------------------------------------------------------
977.有序数组的平方
给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。
示例 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) {
int leftptr=0,rightptr=nums.size()-1;
int index = nums.size()-1;
vector<int> res(nums.size(),0);
while(leftptr<rightptr){
if(abs(nums[leftptr])>abs(nums[rightptr])){//减小运算量,直接比较绝对值
res[index--]=pow(nums[leftptr++],2);//
}else{
res[index--]=pow(nums[rightptr--],2);
}
}
res[0]=pow(nums[leftptr],2);
return res;
}
};
- ^ 是按位异或
时间O(n)
空间O(n)
-------------------------------------------------------------
209.长度最小的子数组 *
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。
示例:
输入:s = 7, nums = [2,3,1,2,4,3] 输出:2 解释:子数组 [4,3] 是该条件下的长度最小的子数组。
暴力算法
== 滑动窗口:双指针的变形 ==
滑动窗口的精妙之处在于根据当前子序列和大小的情况,不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。
class Solution
{
public:
int minSubArrayLen(int target, vector<int> &nums)
{
int leftptr = 0, rightptr = 0;
**int res = INT_MAX; // 最大的int
int sum = 0; // 滑动窗口的总和**
for (rightptr = 0; rightptr < nums.size(); rightptr++)
{
sum += nums[rightptr];
while (sum >= target)
{
res = res < rightptr - leftptr + 1 ? res : rightptr - leftptr + 1;
sum -= nums[leftptr++];
}
}
return res == INT_MAX ? 0 : res;
}
};
- 时间复杂度:O(n)
- 空间复杂度:O(1)
符合了就记录下长度并比较,然后剪掉开头的数值。向右移动开头位置,继续寻找。
-------------------------------------------------------------
59.螺旋矩阵 *
给定一个正整数 n,生成一个包含 1 到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
思路
主要是需要理清思路。
很多同学刚开始做这种题目的时候,上来就是一波判断猛如虎。
结果运行的时候各种问题,然后开始各种修修补补,最后发现改了这里那里有问题,改了那里这里又跑不起来了。
class Solution
{
public:
vector<vector<int>> generateMatrix(int n)
{
// 分类讨论:只有一个数字的情况。后面发现可以合并。
// if (n == 1)
// {
// vector<vector<int>> res(1, vector<int>(1, 1));
// return res;
// }
int circle = n / 2; //需要循环的圈数。
int countline = n - 1; //每一行的个数
int index = 1; //当前打印的数字
int startrow = 0, startclo = 0;//打印位置
vector<vector<int>> res(n, vector<int>(n, 0)); //存储结果
for (int i = 0; i < circle; i++)
{
for (int j = 0; j < countline; j++)
{ //从左到右
res[startrow][startclo++] = index++;
}
for (int j = 0; j < countline; j++)
{ //从上到下
res[startrow++][startclo] = index++;
}
for (int j = 0; j < countline; j++)
{
res[startrow][startclo--] = index++;
}
for (int j = 0; j < countline; j++)
{
res[startrow--][startclo] = index++;
}
//跳转到新循环的打印位置
startrow++;
startclo++;
//每行打印数-2
countline -= 2;
}
//最后内核一圈,奇数才有这种i情况
if (res[startrow][startclo] == 0)
res[startrow][startclo] = index;
return res;
}
};