个人主页 ： zxctscl
如有转载请先通知
题目
- 1. 283. 移动零
- 1.1 分析
- 1.2 代码
- 2. 1089. 复写零
- 2.1 分析
- 2.2 代码
- 3. 202. 快乐数
- 3.1 分析
- 3.2 代码
- 4. 11. 盛最多水的容器
- 4.1 分析
- 4.2 代码
- 5. LCR 179. 查找总价格为目标值的两个商品
- 5.1 分析
- 5.2 代码
- 6. 15. 三数之和
- 6.1 分析
- 6.2 代码
1. 283. 移动零
1.1 分析
一、题目分析
要将0放在所有数组的最后，而且非零元素的顺序保持不变，要求原地对数组进行移动。
二、算法原理
用两个指针来讲数组进行划分，一个cur：从左往右扫描数组，遍历数组；一个dest：已经处理的区间内，非零元素的最后一个位置。
就将数组分为3个区间：非零：[0,dest]；0区间：[dest+1,cur-1]；待处理的区间:[cur,n-1].
要想这样划分，cur就得从前往后在遍历的过程中，遇到0元素，就加加；遇到非零元素，就将dest+1位置和cur位置的值交换。
1.2 代码
class Solution {
public:
void moveZeroes(vector<int>& nums) {
for(int cur=0,dest=-1;cur<nums.size();cur++)
{
if(nums[cur])
{
swap(nums[++dest],nums[cur]);
}
}
}
};
2. 1089. 复写零
2.1 分析
一、题目解析
要求每次遇到0就复写，而且不能改变原数组的长度。
二、算法原理
如果用双指针从前往后遍历，就拿例1来说，
就会出现值被覆盖的情况：
所以遍历顺序就不能从前往后。
那么就把顺序改为从后往前遍历，但是不能超过原数组的长度，就得先找一下cur和dest开始的位置。
可以先用双指针算法：1.先判断cur位置；2.决定dest向后移动一步或者两步；3.判断一下dest是否已经到达结束位置；4.在把cur加加。
但是可能会出现dest越界的情况，如果n-1位置为0，那么cur就减减，dest就减2。
最后在从后往前开始复写0。
2.2 代码
class Solution {
public:
void duplicateZeros(vector<int>& arr) {
int cur=0,dest=-1;
int n=arr.size();
while(cur<n)
{
if(arr[cur])dest++;
else dest+=2;
if(dest>=n-1)break;
cur++;
}
if(dest==n)
{
arr[n-1]=0;
cur--;
dest-=2;
}
while(cur>=0)
{
if(arr[cur])arr[dest--]=arr[cur--];
else
{
arr[dest--]=0;
arr[dest--]=0;
cur--;
}
}
}
};
3. 202. 快乐数
3.1 分析
一、题目分析
题目中所说最后的平方和为1才是快乐数，如果不为1，就一直循环，其实可以看成两个都是循环，一个一直循环的是1，另一个循环的值都不相同。只需要判断循环里面的值是不是为1就可以。
二、算法原理
先用一个变量sum记录最后平方和，然后把最后一位平方，然后删掉原来的数，一直重复这个过程，直到最后一位为0，最后返回这个平方和sum。
定义两个快慢指针，用平方和来充当指针，slow指向第一个数，fast指向第二个数，如果这两个指针一直不相等，就一直循环，slow走一步，fast走两步。直到两个相遇为止，等于1就是快乐数，不等于就不是。
3.2 代码
class Solution {
public:
int bitsum(int n)
{
int sum=0;
while(n)
{
int t=n%10;
sum+=t*t;
n/=10;
}
return sum;
}
bool isHappy(int n) {
int slow=n,fast=bitsum(n);
while(slow!=fast)
{
slow=bitsum(slow);
fast=bitsum(bitsum(fast));
}
return slow==1;
}
};
4. 11. 盛最多水的容器
4.1 分析
一、题目分析
题目中的数组代表每一条线的高度，来求最大的容积，来看一下例1：
选择的高度是8和7，但是题目要求不能倾斜，这里选择高度的就是7，宽度就是下标之间的差值8-1也就是7，那么容积最大就是7*7=49。
二、算法原理
用两个指针来记录容器两边的高度，可以直接先选择最大的宽度，记录下这个容积。
如果左边指针走一步，宽度在减小，高度可能会出现比之前的小，那么体积就比原来的小；高度如果不变，那么宽度减小，那么总容积也是在减小的。所以得干掉高度小的那一个值。
如果两个指针指向的值相等，那么干掉谁都可以，然后继续枚举里面相乘的容积，直到两个指针相遇，最后返回容积最大的值就行。
4.2 代码
class Solution {
public:
int maxArea(vector<int>& height) {
int left=0,right=height.size()-1,v=0;
int ret=0;
while(left<right)
{
v=min(height[left],height[right])*(right-left);
ret=max(ret,v);
if(height[left]<height[right])left++;
else right--;
}
return ret;
}
};
5. LCR 179. 查找总价格为目标值的两个商品
5.1 分析
一、题目分析
只需要找到两个数，他们的和等于目标值就可以，但是题目中的数组是按照升序排列的，暴力解法会超时，就不考虑了。
二、算法原理
利用数组是有序的，用双指针算法来算。
定义两个指针，一个在左边，一个在右边。
先计算两个指针指向值的和，判断一下和目标值的大小，会出现三种情况：1.小于目标值，那么左边指针就加加；2.等于就返回这两个值；3.大于目标值，那么右边指针就减减。
5.2 代码
class Solution {
public:
vector<int> twoSum(vector<int>& price, int target) {
int left=0,right=price.size()-1,sum=0;
while(left<right)
{
sum=price[left]+price[right];
if(sum<target)left++;
else if(sum>target)right--;
else return{price[left],price[right]};
}
return {-1,-1};
}
};
6. 15. 三数之和
6.1 分析
一、题目分析
题目要求返回三元数组和为1的三个不同的数，而且要求去重，来看一下例1：
它里面有[-1,0,1]、[0,1,-1]、[-1,2,-1]，但是第一组和第二组的元素是相同的，就只能返回一个。
为了避免去重，可以先给数组排个序。
二、算法原理
排序之后，数据是有序的，这里就用双指针算法。
这里是三个数的和，可以先固定一个数a，仅想要保证这个a是小于0就行（在后面等于0相加的值不可能等于0），然后在该数后面的区间内，利用双指针算法，快速找到两个数的和，者两个数的和是a的相反数，这样这三个数相加的时候，值就为0。
这里还有可能不止一种情况，所以不要漏掉，在找到一种情况时候，左边指针和右边指针继续缩小区间找，直到两个指针相同。
那么怎么去重，已经是有序的数组，那么连续相同值的情况就不考虑了，就是在左边指针和右边指针已经找到值，就跳过重复的值。当使用完重复的元素时候，固定值也得跳过重复值。还得避免越界的情况。
6.2 代码
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
sort(nums.begin(),nums.end());
vector<vector<int>> ret;
int n=nums.size();
for(int i=0;i<n;)
{
if(nums[i]>0)break;
int left=i+1,right=n-1,target=-nums[i];
while(left<right)
{
int sum=nums[left]+nums[right];
if(sum<target) left++;
else if(sum>target)right--;
else
{
ret.push_back({nums[i],nums[left],nums[right]});
left++;right--;
while(left<right&&nums[left]==nums[left-1])left++;
while(left<right&&nums[right]==nums[right+1])right--;
}
}
i++;
while(i<n&&nums[i]==nums[i-1])i++;
}
return ret;
}
};
有问题请指出，大家一起进步！！！
