算法—双指针

双指针算法可以帮忙把时间复杂度降低一个维度，即原本O（n2）降为O(n)；将O(n)降为O(1)

移动零

移动零

题目解析

  1. 将所有0移动到末尾
  2. 保持非0元素相对顺序
  3. 对数组进行原地操作（不开辟额外空间）

image.png

算法原理

数组划分/数组分块——划分为非0元素和0元素两个区间
解决方法：双指针算法（利用数组下标充当指针）
原理： ⽤⼀个 cur 指针来扫描整个数组，另⼀个 dest 指针⽤来记录⾮零数序列 的最后⼀个位置。根据 cur 在扫描的过程中，遇到的不同情况，分类处理，实现数组的划分。 在 cur 遍历期间，使 [0, dest] 的元素全部都是⾮零元素， [dest + 1, cur - 1] 的 元素全是零。

流程：

  • ** **a. 初始化 cur = 0 （⽤来遍历数组）， dest = -1 （指向⾮零元素序列的最后⼀个位置。 因为刚开始我们不知道最后⼀个⾮零元素在什么位置，因此初始化为 -1 ）

  • b. cur 依次往后遍历每个元素，遍历到的元素会有下⾯两种情况：

      i. 遇到的元素是 0 ， cur 直接 ++ 。因为我们的⽬标是让 [dest + 1, cur - 1] 内 的元素全都是零，因此当 cur 遇到 0 的时候，直接 ++ ，就可以让 0 在 cur - 1 的位置上，从⽽在 [dest + 1, cur - 1] 内； <br />ii. 遇到的元素不是 0 ， dest++ ，并且交换 cur 位置和 dest 位置的元素，之后让 cur++ ，扫描下⼀个元素。<br /> • 因为 dest 指向的位置是⾮零元素区间的最后⼀个位置，如果扫描到⼀个新的⾮零元 素，那么它的位置应该在 dest + 1 的位置上，因此 dest 先⾃增 1 ； <br />• dest++ 之后，指向的元素就是 0 元素（因为⾮零元素区间末尾的后⼀个元素就是 0 ），因此可以交换到 cur 所处的位置上，实现 [0, dest] 的元素全部都是⾮零 元素， [dest + 1, cur - 1] 的元素全是零。  <br />![](https://img-blog.csdnimg.cn/img_convert/b7395e9bf3e416bdc29fd71ea0ac02a4.jpeg)

代码实现

class Solution {
public:void moveZeroes(vector<int>& nums) {for (int cur = 0, dest = -1; cur < nums.size(); cur++){if(nums[cur]) //处理非0元素swap(nums[++dest],nums[cur]);}}
};

复写零

复写零

题目解析

  1. 不要超过数组长度
  2. 不要开辟额外空间

算法原理

解法：依旧是双指针算法
思路：先根据"异地"操作，然后优化成双指针下的"就地"操作image.png

流程：

  1. 先找到最后一个复写的数
  2. 处理边界情况（eg：1，0，2，3，0，4这样dest最终会造成越界访问）
  3. 从后向前完成复写操作

注意：这里不能从前向后进行复写，否则会覆盖掉后面的数字

a. 初始化两个指针 cur = 0 ， dest = 0 ；
b. 找到最后⼀个复写的数：
i. 当cur < n 的时候，⼀直执⾏下⾯循环：
• 判断 cur 位置的元素:
◦ 如果是 0 的话， dest 往后移动两位；
◦ 否则， dest 往后移动⼀位。
• 判断dest 时候已经到结束位置，如果结束就终⽌循环；
• 如果没有结束， cur++ ，继续判断。
c. 判断 dest 是否越界到 n 的位置：
i. 如果越界，执⾏下⾯三步：

  1. n - 1 位置的值修改成 0 ；
  2. cur 向移动⼀步；
  3. dest 向前移动两步。

d. 从cur 位置开始往前遍历原数组，依次还原出复写后的结果数组：
i. 判断cur 位置的值：

  1. 如果是 0 ： dest 以及 dest - 1 位置修改成 0 ， dest -= 2 ；
  2. 如果⾮零： dest 位置修改成 0 ， dest -= 1 ；
    ii. cur-- ，复写下⼀个位置

代码实现

class Solution {
public:void duplicateZeros(vector<int>& arr) {//1.先找到最后一个数int cur = 0;int dest = -1;while(cur<arr.size()){if(arr[cur])dest++;else dest += 2;if(dest >= arr.size()-1) break;cur++;        }//2.处理边界情况if(dest==arr.size()){arr[arr.size()-1] = 0;cur--;dest -= 2;}//3.从后向前复写while(cur >= 0){if(arr[cur])arr[dest--] = arr[cur--];else{arr[dest--] = 0;arr[dest--] = 0;cur--;}    }}
};

快乐数

快乐数

题目解析

  • 题目定义快乐数的第一种情况：这个数会变成1，是快乐数

image.png

  • 题目定义快乐数的第二种情况：会陷入某一个环里开始循环，永远变不为1所以不是快乐数

image.png

算法原理

  • 第一种情况相当于也是一个环，只不过环中所有的数都是1
  • 第二种情况所有环中的数都不是1

所以以上两种情况抽象成一种，即总会进入一个环里开始循环。故只需要判断链表里是否有1就能确定是否有快乐数。（ps：类似判断列表是否有环——快慢指针）

快慢指针：慢指针每次向后移动一步，快指针每次向后移动两步；判断相遇时候的值即可

题目中告诉我们最终出现的两种情况——1.变成1一直循环下去 2.在循环里永远变不为1。若题目不给出这句话，我们也可以证明出来

鸽巢原理（抽屉原理）
n个鸽巢，n+1只鸽子——至少会有一个巢穴有大于1的鸽子数
题目中数据范围时int的最大值231-1（2.1*109） 让这个数再大一点，方便我们确定范围
image.png
因为最大的数只能到810，每次变化时都会落在[1,810]这个区间里，所以当我们变化次数超过810时，他一定会有重复的数字落入这个范围里，即一定会进入环里。

代码实现

class Solution {
public:
// 返回 n 这个数每⼀位上的平⽅和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;}
};

盛水最多的容器

盛水最多的容器

题目解析

选两条线，取较小的（木桶原理）与x轴进行相乘算出容积

算法原理

  1. 暴力枚举：先固定最左边的线，依次乘，把所有情况全算出来找出最大值（两层for循环）时间复杂度O(n^2)image.png

  2. 利用单调性，使用双指针，即对撞指针（时间复杂度O(n)，空间复杂度O(1)）

  • 先寻找规律：即随便取两个数，研究一个小区间，然后拿两个中较小的数向内枚举。如图可以看出，要么h会减小，要么w宽度会减小，所以直接把4这个数字pass掉，不需要进行枚举。image.png

  • 扩大规律，直接拿最左边的数和最右边的数，计算出V1，然后向内枚举时可以舍弃掉1（较小的数），研究下一段区间。当两个指针相遇时，我们计算出所有的V取最大值即可。image.png

代码实现

class Solution {
public:int maxArea(vector<int>& height) {int left = 0, right = height.size() - 1, ret = 0;while(left < right){int v = min(height[left], height[right]) * (right - left);ret = max(ret, v);// 移动指针if(height[left] < height[right]) left++;else right--;}return ret;}
};

有效三角形个数

有效三角形个数

题目解析

emm三角形两边之和大于第三边（hhhh）

算法原理

  • 暴力枚举——令a+b>c a+c>b b+c>a三个条件同时成立即可，但这个方法要判断三次

判断三⻆形的优化：

  • 如果能构成三⻆形，需要满⾜任意两边之和要⼤于第三边。但是实际上只需让较⼩的两条边之和⼤于第三边即可。
  • 因此我们可以先将原数组排序，然后从⼩到⼤枚举三元组，⼀⽅⾯省去枚举的数量，另⼀⽅⾯⽅便判断是否能构成三⻆形 
//超时
class Solution {
public:
int triangleNumber(vector<int>& nums) {// 1. 排序sort(nums.begin(), nums.end());int n = nums.size(), ret = 0;// 2. 从⼩到⼤枚举所有的三元组for (int i = 0; i < n; i++) {for (int j = i + 1; j < n; j++) {for (int k = j + 1; k < n; k++) {// 当最⼩的两个边之和⼤于第三边的时候，统计答案if (nums[i] + nums[j] > nums[k])ret++;}}}return ret;
}
};

image.png

  • 单调性，双指针

先将数组排序。根据「解法⼀」中的优化思想，我们可以固定⼀个「最⻓边」，然后在⽐这条边⼩的有序数组中找出⼀个⼆元组，使这个⼆元组之和⼤于这个最⻓边。由于数组是有序的，我们可以利⽤「对撞指针」来优化。
设最⻓边枚举到 i 位置，区间[left, right] 是 i 位置左边的区间（也就是⽐它⼩的区间）：

  1. 如果 nums[left] + nums[right] > nums[i] ：
  2. 说明 [left, right - 1] 区间上的所有元素均可以与 nums[right] 构成⽐nums[i] ⼤的⼆元组
  3. 满⾜条件的有 right - left 种情况（下标相减）
  4. 此时 right 位置的元素的所有情况相当于全部考虑完毕， right-- ，进⼊下⼀轮判断
  5. 如果 nums[left] + nums[right] <= nums[i] ：
    1. 说明 left 位置的元素是不可能与 [left + 1, right] 位置上的元素构成满⾜条件的⼆元组
    2. left 位置的元素可以舍去， left++ 进⼊下轮循环 （即换一个固定的数，重复上述过程）

image.png

代码实现

class Solution {
public:int triangleNumber(vector<int>& nums) {// 1. 优化sort(nums.begin(), nums.end());// 2. 利⽤双指针解决问题int ret = 0, n = nums.size();for(int i = n - 1; i >= 2; i--) // 先固定最⼤的数{// 利⽤双指针快速统计符合要求的三元组的个数int left = 0, right = i - 1;while(left < right){if(nums[left] + nums[right] > nums[i]){ret += right - left;right--;}else{left++;}}}return ret;}
};

和为s的两个数字

和为s的两个数字

题目解析

  • 数组是有序的
  • 最终结果返回数字，如果有多对，只需返回一对即可

算法原理

  1. 暴力解法

仅需两个for循环，先固定一个数，挨个相加。但没有利用数组有序的特性。image.png

  1. 双指针算法——对撞指针
    1. 当left+right > target；那么right所指的数舍去，right–
    2. 当left+right < target；那么[left+1，right] 之间的数都不可能满足，所以left++
    3. 当left+right = target; 返回

image.png

代码实现

class Solution {
public:vector<int> twoSum(vector<int>& price, int target) {int left = 0,right = price.size()-1;while(left < right){int sum = price[left] + price[right];if (sum < target) left++;else if(sum > target) right--;else return{price[left],price[right]}; //C++语法，初始化列表（隐形转换，会自动转换成vector<int>）}//照顾编译器，让所有路径有返回值return{-4221,-1};}
};
//当返回值是vector,并且只需要返回两个变量时，可以用初始化列表写法

三数之和

三数之和

题目解析

  1. 要求选三个不同位置的数
  2. 注意中的不允许重复是指即使三个数位置不同，也都满足结果，但因为元素一样，所以只选择一组即可image.png

算法原理

  • 解法一：排序+暴力枚举+set去重

去重操作我们是使用容器进行，是常数级别，可以忽略不计，在面试时，往往要求我们不使用现成的容器进行去重image.png

  • 解法二：排序+双指针

（有点类似上道题的两数之和） 这里去重我们尝试不使用容器set
注意：

  1. 「去重」操作:
    1. 找到⼀个结果之后， left 和 right 指针要「跳过重复」的元素；
    2. 当使⽤完⼀次双指针算法之后，固定的 a 也要「跳过重复」的元素 ；（-4 -4）
    3. 去重操作移动指针时，要避免越界（【0，0，0，0，】）
  2. 不漏操作
    1. 找到一种结果后，双指针不要听继续缩小空间寻找
  3. （常数级别的小优化）固定数字a时，只需要固定a<0的数，因为数组经过排序后，后面的正数无论怎么组合也不会出现负数的情况，所以只需要固定a<0的数


image.png

代码实现

class Solution {
public:vector<vector<int>> threeSum(vector<int>& nums){vector<vector<int>> ret;// 1. 排序sort(nums.begin(), nums.end());// 2. 利⽤双指针解决问题int n = nums.size();for(int i = 0; i < n; ) // 固定数 a{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) right--;else if(sum < target) left++;else{//大括号会直接形成vector<int>数组，存储到ret里ret.push_back({nums[i], nums[left], nums[right]});//不漏left++, right--;// 去重操作 left 和 right 且 避免越界while(left < right && nums[left] == nums[left - 1]) left++;while(left < right && nums[right] == nums[right + 1])right--;}}/* 去重 i 且i也不能越界（这里先让i移动下一个位置，然后去之前的值比较若相等，继续移动。我们这里去重操作在for循环最后，所以为避免多++一个位置删除for循环里的++ */i++;while(i < n && nums[i] == nums[i - 1]) i++;}return ret;}
};

四数之和

四数之和

题目解析

与三数之和类似

算法原理

  • 解法一：排序+暴力枚举+set去重

  • 解法二：排序+双指针

先依次固定一个数记为a，剩余后面的数利用**“ 三数之和“**的思想，找到三个数，使其和为target-a。
依次固定一个数b，在b后面的区间，利用双指针找到使其和为target-a-b.image.png

同样需要处理细节问题：不重、不漏

  1. 不重（3个地方）
    1. 当left和right找到结果时，要跳过相同的数
    2. 当利用完双指针寻找完之后，b也要跳过相同的数
    3. 当找出三数之和后，a也要跳过相同的数
  2. 不漏：在我们利用双指针寻找结果为target-a-b时，当找到一个结果时，不要停继续缩小区间寻找结果

代码实现

class Solution {
public:vector<vector<int>> fourSum(vector<int>& nums, int target) {//定义结果数组vector<vector<int>> ret;//1.排序sort(nums.begin(),nums.end());//2.利用双指针int n = nums.size();for(int i = 0;i < n;) //固定a{//利用三数之和for(int j = i+1;j<n;) //固定b{int left = j + 1,right = n-1;long long aim =(long long) target-nums[i]-nums[j]; //目标值target-a-b   //这里提交leetcode会提示数据溢出的错误，换成longlongwhile(left<right){int sum = nums[left]+nums[right];if(sum < aim) left++;else if(sum > aim) right--;else{ret.push_back({nums[i],nums[j],nums[left],nums[right]});//找到之后继续缩小区间防止漏left++;right--;//去重一双指针while(left<right && nums[left] == nums[left-1]) left++;while(left<right && nums[right] == nums[right+1]) right--;}}//去重二bj++;while(j<n && nums[j]==nums[j-1]) j++;}//去重ai++;while(i<n && nums[i] == nums[i-1]) i++;}return ret;}
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/225545.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

抖音票务小程序开发：从零到一的全面指南

抖音票务小程序开发：从零到一的全面指南

本文将深入介绍如何从零开始开发一款抖音票务小程序&#xff0c;为读者提供全面的指南&#xff0c;帮助他们实现从概念到实际应用的全过程。 第一步&#xff1a;理清需求与目标 在开发任何应用之前&#xff0c;清晰的需求和明确的目标是成功的关键。在这一阶段&#xff0c;你…
阅读更多...
【前端首屏加载速度优化(0)： 谷歌浏览器时间参数】

【前端首屏加载速度优化(0)： 谷歌浏览器时间参数】

DOMContentLoaded 浏览器已经完全加载了 HTML&#xff0c;DOM树构建完成&#xff0c;但是像是 <img> 和样式表等外部资源可能并没有下载完毕。 Load DOM树构建完成后&#xff0c;继续加载 html/css 中的外部资源&#xff0c;加载完成之后&#xff0c;视为页面加载完成。…
阅读更多...
论文绘图——局部细节放大

论文绘图——局部细节放大

文章目录 前言一、绘图1.0版二、绘图2.0版三、总结 前言 我们经常在论文中会看到下面这些样式的图片&#xff1a;在图片中使用矩形框框出感兴趣的区域&#xff0c;然后在底部或者其他位置附上对应的局部放大的细节图&#xff0c;简洁好看。✨ 曾尝试使用过PPT制作&#xff0c;也…
阅读更多...
js文本框只能输入数字且100的倍数

js文本框只能输入数字且100的倍数

var a123 var b200
阅读更多...
Leetcode—907.子数组的最小值之和【中等】

Leetcode—907.子数组的最小值之和【中等】

2023每日刷题&#xff08;四十二&#xff09; Leetcode—907.子数组的最小值之和 算法思想 参考自y神思想 实现代码 class Solution { public:int sumSubarrayMins(vector<int>& arr) {long long ans 0;const int mod 1e97;int n arr.size();stack<int>…
阅读更多...
怎么解决 申请获取你的手机号，但该功能使用次数已达当前小程序上限，暂时无法使用。

怎么解决 申请获取你的手机号，但该功能使用次数已达当前小程序上限，暂时无法使用。

微信出新规了&#xff0c; 获取手机号数据需要收费&#xff0c;1分钱一条。 在以前的开发中&#xff0c;获取手机号是默认不需要收费的&#xff0c;现在收费等于微信现在作为运营商一样&#xff0c;验证一个手机短信&#xff0c;需要收费 几分钱。 如果你的程序遇到了问题&am…
阅读更多...
GPTS-生成一个动漫图像GPT

GPTS-生成一个动漫图像GPT

介绍 GPTs是ChatGPT的定制版本,用户可以通过组合指令、知识和功能来定制用于特定任务或主题的GPT。它们可以根据需要简单或复杂,解决从语言学习到技术支持等各种事情。 创建GPTs Plus和Enterprise用户可以在chat.openai.com/create上开始创建GPTs。 您可以通过在ChatGPT上的…
阅读更多...
【javaWeb】HTTP协议

【javaWeb】HTTP协议

HTTP (全称为 “超文本传输协议”) 是一种应用非常广泛的应用层协议 HTTP 是一个文本格式的协议. 可以通过 Chrome 开发者工具或者 Fiddler 抓包, 分析 HTTP 请求/响应的细节. 上图是通过Fiddler对访问百度搜索页时抓取的一个http协议的包。 观察抓包结果,可以看到,当前 http…
阅读更多...
LeetCode（33）最小覆盖子串【滑动窗口】【困难】

LeetCode（33）最小覆盖子串【滑动窗口】【困难】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 76. 最小覆盖子串 1.题目 给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串&#xff0c;则返回空字符串 "" 。 注意&#xff1a; 对于 t 中重复字…
阅读更多...
Java数据结构之优先级队列(PriorityQueue)

Java数据结构之优先级队列(PriorityQueue)

1、概念 队列&#xff1a;是一种FIFO&#xff08;First-In-First-Out&#xff09;先进先出的数据结构&#xff0c;对应于生活中的排队的场景&#xff0c; 排在前面的人总是先通过&#xff0c;依次进行。 优先队列&#xff1a;是特殊的队列&#xff0c;从“优先”一词&#xff…
阅读更多...
C# 实现微信退款及对帐

C# 实现微信退款及对帐

目录 需求 基础准备 关键代码 操作界面 ​编辑 退款订单类及方法 退款功能实现 对帐 支付商家后台相关要点 实时交易帐单查询 精确交易帐单查询 小结 需求 在招聘报名系统里&#xff0c;考务费支付是其中一个环节&#xff0c;支付方式很多种&#xff0c;比如银联、…
阅读更多...
GitHub----使用记录

GitHub----使用记录

一、上传文件到仓库 1、首先新建一个github仓库 然后先记住这一句指令 2、下载git工具 https://git-scm.com/downloads 下载工具安装不用运行 3、使用git工具上传文件并推送 找到你想上传的文件的位置&#xff0c;右击git Bush here git init &#xff1a;初始化这个仓…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023