【优选算法篇】双指针的华丽探戈：深入C++算法殿堂的优雅追寻

Trouvaille ~2024-10-17 19:10

文章目录

C++ 双指针详解：进阶题解与思维分析

💬 欢迎讨论：如有疑问或见解，欢迎在评论区留言互动。

👍 点赞、收藏与分享 ：如觉得这篇文章对您有帮助，请点赞、收藏并分享！

🚀 分享给更多人：欢迎分享给更多对 C++ 感兴趣的朋友，一起学习双指针的基础与进阶！

前言

接上篇【优选算法篇】双指针的优雅舞步：C++ 算法世界的浪漫探索

本篇文章将带领大家进入双指针的进阶领域。在基础篇中，我们已经学习了如何利用双指针优化简单数组问题，而在这一篇中，我们将进一步深入探讨双指针的高级应用场景，包括排序问题、多数之和等经典题型的双指针解法，以及如何利用双指针快速解决复杂的数组与链表问题。
通过更加深入的题目分析和双指针的高级策略，我们希望大家能够更加熟练地运用这一算法技巧，应对更具挑战性的编程问题。让我们继续双指针的优雅舞步，开启 C++ 算法世界的浪漫探索！

第一章：有效三角形的个数

1.1 有效三角形的个数

题目链接 ：611. 有效三角形的个数
题目描述 ：给定一个包含非负整数的数组 nums，返回其中可以组成三角形三条边的三元组个数。

示例 1：
  • 输入：nums = [2, 2, 3, 4]
  • 输出：3
  • 解释：有效的组合是：
    • 2, 3, 4 （使用第一个 2）
    • 2, 3, 4 （使用第二个 2）
    • 2, 2, 3
示例 2：
  • 输入：nums = [4, 2, 3, 4]
  • 输出：4
  • 解释：
    • 4, 2, 3
    • 4, 2, 4
    • 4, 3, 4
    • 2, 3, 4
解法一（暴力求解）

算法思路：

  • 三层 for 循环枚举出所有的三元组，并判断是否能构成三角形。
  • 判断三角形的优化：
    • 如果能构成三角形，需要满足任意两边之和大于第三边。但实际上只需让较小的两条边之和大于第三边即可。
    • 因此可以先将原数组排序，然后从小到大枚举三元组，一方面省去枚举的数量，另一方面方便判断是否能构成三角形。

代码实现：

cpp 复制代码 
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;
    }
};

复杂度分析：

  • 时间复杂度 ：O(n^3)，对于较大的输入，三层循环会导致性能问题，适合小规模数据。
  • 空间复杂度 ：O(1)，只使用了常数个变量存储结果和中间值。
解法二（排序 + 双指针）

算法思路：

  • 先将数组排序。
  • 根据「解法一」中的优化思想，可以固定一个「最长边」，然后在比这条边小的有序数组中找出一个二元组，使这个二元组之和大于这个最长边。由于数组是有序的，我们可以利用「对撞指针」来优化。
  • 设最长边枚举到位置 i，区间 [left, right] 是 i 位置左边的区间（也就是比它小的区间）：
    • 如果 nums[left] + nums[right] > nums[i]：
      • 说明 [left, right - 1] 区间上的所有元素均可以与 nums[right] 构成比 nums[i] 大的二元组。
      • 满足条件的有 right - left 种。
      • 此时 right 位置的元素的所有情况相当于全部考虑完毕，right--，进入下一轮判断。
    • 如果 nums[left] + nums[right] <= nums[i]：
      • 说明 left 位置的元素不可能与 [left + 1, right] 位置上的元素构成满足条件的二元组。
      • left 位置的元素可以舍去，left++ 进入下一轮循环。

代码实现：

cpp 复制代码 
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;
    }
};

复杂度分析：

  • 时间复杂度 ：O(n^2)，排序的时间复杂度为 O(n log n)，之后每个元素使用双指针进行一次遍历，时间复杂度为 O(n^2)。
  • 空间复杂度 ：O(1)，只使用了常数个变量存储结果和指针位置。
易错点提示
  1. 指针移动逻辑 ：在双指针遍历时，根据条件选择移动 left 或 right，确保找到所有满足条件的三元组。
  2. 数组排序：在开始双指针遍历之前，必须对数组进行排序，否则无法保证正确性。
  3. 三角形判定条件：确保只需判断两边之和是否大于第三边，简化条件判断，避免遗漏有效三元组。
代码解读

该算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)，适合大规模输入。通过排序和双指针优化，能够有效减少暴力求解中的不必要计算，提升性能。此方法非常适合在数组问题中应用，能够快速找到所有满足条件的组合。

第二章：和为 s 的两个数字

2.1 和为 s 的两个数字

题目链接 ：剑指 Offer 57. 和为s的两个数字
题目描述 ：输入一个递增排序的数组和一个数字 s，在数组中查找两个数，使得它们的和正好是 s。如果有多对数字的和等于 s，则输出任意一对即可。

示例 1：
  • 输入：nums = [2, 7, 11, 15], target = 9
  • 输出：[2, 7] 或者 [7, 2]
解法一（暴力解法）

算法思路：

  • 两层 for 循环列出所有两个数字的组合，判断是否等于目标值。

算法流程：

  • 两层 for 循环：
    • 外层 for 循环依次枚举第一个数 a；
    • 内层 for 循环依次枚举第二个数 b，让它与 a 匹配；
    • 然后将挑选的两个数相加，判断是否符合目标值。

代码实现：

cpp 复制代码 
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (nums[i] + nums[j] == target)
                    return {nums[i], nums[j]};
            }
        }
        return {-1, -1};
    }
};
解法二（双指针 - 对撞指针）

算法思路：

  • 注意到本题是升序的数组，因此可以使用「对撞指针」优化时间复杂度。

算法流程：

  • 初始化 left，right 分别指向数组的左右两端：
    • 当 left < right 的时候，一直循环：
      • 当 nums[left] + nums[right] == target 时，说明找到结果，记录结果，并返回；
      • 当 nums[left] + nums[right] < target 时：
        • 说明当前和小于目标值，需要增大和，left++；
      • 当 nums[left] + nums[right] > target 时：
        • 说明当前和大于目标值，需要减小和，right--。

代码实现：

cpp 复制代码 
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left < right) {
            int sum = nums[left] + nums[right];
            if (sum > target) right--;
            else if (sum < target) left++;
            else return {nums[left], nums[right]};
        }
        //这是为了照顾编译器，不然编译器报错：不是所有的路径都有返回值
        return {-1, -1};
    }
};

第三章：三数之和与四数之和

3.1 三数之和

题目链接 ：15. 三数之和
题目描述 ：给你一个整数数组 nums，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k，同时还满足 nums[i] + nums[j] + nums[k] == 0。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：
  • 输入：nums = [-1, 0, 1, 2, -1, -4]
  • 输出：[[-1, -1, 2], [-1, 0, 1]]
  • 解释：
    • nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0。
    • nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0。
    • nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0。
    • 不同的三元组是 [-1, 0, 1] 和 [-1, -1, 2]。
    • 注意，输出的顺序和三元组的顺序并不重要。
示例 2：
  • 输入：nums = [0, 1, 1]
  • 输出：[]
  • 解释：唯一可能的三元组和不为 0。
示例 3：
  • 输入：nums = [0, 0, 0]
  • 输出：[[0, 0, 0]]
  • 解释：唯一可能的三元组和为 0。
提示：
  • 3 <= nums.length <= 3000
  • -10^5 <= nums[i] <= 10^5
解法（排序+双指针）

算法思路：

  • 本题与两数之和类似，是非常经典的面试题。
  • 与两数之和稍微不同的是，题目中要求找到所有「不重复」的三元组。我们可以利用双指针思想来对暴力枚举做优化：
    1. 先排序；
    2. 然后固定一个数 a；
    3. 在这个数后面的区间内，使用「双指针算法」快速找到两个数之和等于 -a 即可。
  • 需要注意的是，这道题中需要有「去重」操作：
    1. 找到一个结果之后，left 和 right 指针要「跳过重复」的元素；
    2. 当使用完一次双指针算法之后，固定的 a 也要「跳过重复」的元素。

代码实现：

cpp 复制代码 
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 {
                    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++;
            while (i < n && nums[i] == nums[i - 1]) i++;
        }
        return ret;
    }
};

3.2 四数之和

题目链接 ：18. 四数之和
题目描述 ：给你一个由 n 个整数组成的数组 nums，和一个目标值 target。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]]（若两个四元组元素一一对应，则认为两个四元组重复）：

  • 0 <= a, b, c, d < n
  • a、b、c 和 d 互不相同
  • nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按任意顺序返回答案。

示例 1：
  • 输入：nums = [1, 0, -1, 0, -2, 2], target = 0
  • 输出：[[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]
示例 2：
  • 输入：nums = [2, 2, 2, 2, 2], target = 8
  • 输出：[[2, 2, 2, 2]]
提示：
  • 1 <= nums.length <= 200
  • -10^9 <= nums[i] <= 10^9
  • -10^9 <= target <= 10^9
解法（排序 + 双指针）

算法思路：

  1. 依次固定一个数 a；
  2. 在这个数 a 的后面区间上，利用「三数之和」找到三个数，使这三个数的和等于 target - a 即可。

代码实现：

cpp 复制代码 
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];
                while (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--;
                    }
                }
                // 去重 j
                j++;
                while (j < n && nums[j] == nums[j - 1]) j++;
            }
            // 去重 i
            i++;
            while (i < n && nums[i] == nums[i - 1]) i++;
        }
        return ret;
    }
};

写在最后

在本篇文章中，我们沿着双指针的足迹，走进了更为复杂的算法世界。从基础的排序与两数之和，到多元问题的优化解法，双指针以其灵活而高效的策略，为我们提供了简洁优雅的解题思路。无论是解锁数组中的隐藏结构，还是精确处理链表中的循环，双指针始终如同算法中的舞者，轻巧地穿梭于问题的复杂性之间，帮助我们化繁为简。
希望通过这些进阶题解，大家能不仅熟悉双指针的运用技巧，更能深刻体会到算法设计中的思维之美。未来的算法旅程中，无论面对怎样的挑战，双指针这一工具都能在你的编程工具箱中，成为应对复杂问题时得心应手的利器。

以上就是关于【优选算法篇】双指针的华丽探戈：深入C++算法殿堂的优雅追寻的内容啦，各位大佬有什么问题欢迎在评论区指正，或者私信我也是可以的啦，您的支持是我创作的最大动力！❤️

相关推荐
骇客野人几秒前
【JAVA】JAVA接口公共返回体ResponseData封装
java·开发语言
black^sugar2 分钟前
纯前端实现更新检测
开发语言·前端·javascript
404NooFound7 分钟前
Python轻量级NoSQL数据库TinyDB
开发语言·python·nosql
菌菌的快乐生活13 分钟前
理解支持向量机
算法·机器学习·支持向量机
大山同学18 分钟前
第三章线性判别函数（二）
线性代数·算法·机器学习
axxy200037 分钟前
leetcode之hot100---240搜索二维矩阵II（C++）
数据结构·算法
黑客Ash1 小时前
安全算法基础（一）
算法·安全
GISer_Jing1 小时前
2025前端面试热门题目——计算机网络篇
前端·计算机网络·面试
m0_748245521 小时前
吉利前端、AI面试
前端·面试·职场和发展
用余生去守护1 小时前
python报错系列(16)--pyinstaller ????????
开发语言·python
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04机器人编程怎么入门？05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07SQL 主从数据库实时备份08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10VSCode插件 —— Cody AI （免费AI助手！）