文章目录
- 双指针算法
- 一、 移动零
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 二、 复写零
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 三、 快乐数
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 四、 盛水最多的容器
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 五、有效三角形的个数
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 六、 和为 s 的两个数字
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 七、 三数之和
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 八、 四数之和
- 1. 题目
- 2. 算法思想
- 3. 代码实现
- 总结
双指针算法
好的，完全按照你的话重构如下：
常见的双指针有两种形式，一种是对撞指针，一种是左右指针。
对撞指针：一般用于顺序结构中，也称左右指针。
- 对撞指针从两端向中间移动。一个指针从最左端开始，另一个从最右端开始，然后逐渐往中间逼近。
- 对撞指针的终止条件一般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循环），也就是：
- left == right（两个指针指向同一个位置）
- left > right（两个指针错开）
快慢指针：又称为龟兔赛跑算法，其基本思想就是使用两个移动速度不同的指针在数组或链表等序列结构上移动。
这种方法对于处理环形链表或数组非常有用。
其实不单单是环形链表或者是数组，如果我们要研究的问题出现循环往复的情况时，均可考虑使用快慢指针的思想。
快慢指针的实现方式有很多种，最常用的一种就是：
- 在一次循环中，每次让慢的指针向后移动一位，而快的指针往后移动两位，实现一快一慢。
一、 移动零
1. 题目
移动零
2. 算法思想
3. 代码实现
class Solution {
public:
void moveZeroes(vector<int>& nums)
{
for(int cur = 0, dest = -1; cur < nums.size(); cur++)
{
if(nums[cur])
{
swap(nums[cur], nums[++dest]);
}
}
}
};
二、 复写零
1. 题目
复写零
2. 算法思想
3. 代码实现
class Solution {
public:
void duplicateZeros(vector<int>& arr)
{
int cur = 0, dest = -1, 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;
dest -= 2;
cur--;
}
while(cur >= 0)
{
if(arr[cur]) arr[dest--] = arr[cur--];
else
{
arr[dest--] = 0;
arr[dest--] = 0;
cur--;
}
}
}
};
三、 快乐数
1. 题目
快乐数
2. 算法思想
3. 代码实现
class Solution {
public:
int bitSum(int n)
{
int sum = 0;
while(n)
{
int tmp = n % 10;
sum = sum + tmp * tmp;
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;
}
};
四、 盛水最多的容器
1. 题目
盛水最多的容器
2. 算法思想
3. 代码实现
class Solution {
public:
int maxArea(vector<int>& height)
{
int left = 0, right = height.size() - 1;
int ret = 0;
while(left < right)
{
int v = (right - left) * min(height[left], height[right]);
ret = max(ret, v);
if(height[left] < height[right]) left++;
else right--;
}
return ret;
}
};
五、有效三角形的个数
1. 题目
有效三角形的个数
2. 算法思想
3. 代码实现
class Solution {
public:
int triangleNumber(vector<int>& nums)
{
sort(nums.begin(), nums.end());
int n = nums.size() - 1;
int ret = 0;
for(int i = n; i >= 2; i--)
{
int left = 0, right = i - 1;
while(left < right)
{
if(nums[left] + nums[right] > nums[n])
{
ret = ret + right - left;
right--;
}
else left++;
}
}
return ret;
}
};
六、 和为 s 的两个数字
1. 题目
和为 s 的两个数字
2. 算法思想
3. 代码实现
class Solution {
public:
vector<int> twoSum(vector<int>& price, int target)
{
sort(price.begin(), price.end());
int n = price.size() - 1;
int left = 0, right = n;
while(left < right)
{
if(price[left] + price[right] < target) left++;
else if(price[left] + price[right] > target) right--;
else return {price[left], price[right]};
}
return {-1, -1};
}
};
七、 三数之和
1. 题目
三数之和
2. 算法思想
3. 代码实现
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums)
{
vector<vector<int>> ret;
sort(nums.begin(), nums.end());
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[left], nums[right], nums[i]});
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;
}
};
八、 四数之和
1. 题目
四数之和
2. 算法思想
3. 代码实现
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target)
{
vector<vector<int>> ret;
sort(nums.begin(), nums.end());
int n = nums.size();
for(int i = 0; i < n ; )
{
for(int j = i + 1; j < n; )
{
int left = j + 1, right = n - 1;
long long aim = (long long)target - nums[i] - nums[j];
while(left < right)
{
int sum = nums[left] + nums[right];
if(sum < aim) left++;
else if(sum > aim) right--;
else
{
ret.push_back({nums[left++], nums[right--], nums[i], nums[j]});
while(left < right && nums[left] == nums[left - 1]) left++;
while(left < right && nums[right] == nums[right + 1]) right--;
}
}
j++;
while(j < n && nums[j] == nums[j - 1]) j++;
}
i++;
while(i < n && nums[i] == nums[i - 1]) i++;
}
return ret;
}
};
总结
双指针的问题要注意处理边界，能用双指针处理就尽量用双指针做，时间复杂度会降一级~
谢谢大家~
