【LeetCode】双指针题解汇总

于 2022-08-03 15:27:23 发布
阅读量828 收藏 1
点赞数 2
分类专栏： leetcode刷题笔记（JavaScript） 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52834435/article/details/126141366
版权

【LeetCode】双指针题解汇总

文章目录

写在前面

这里是小飞侠Pan🥳，立志成为一名优秀的前端程序媛！！！

本篇文章同时收录于我的github前端笔记仓库中，持续更新中，欢迎star~

👉https://github.com/mengqiuleo/myNote


11. 盛最多水的容器

11. 盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) ，找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

在这里插入图片描述

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

题解思路

  • 使用双指针，左右指针分别指向数组的开始和结束的位置
  • 每次都会计算出左右指针的容量，然后向中间逐渐移动指针，直到两个指针相遇
  • 如果左指针的高度小于右指针，那就移动左指针。反之亦然。
var maxArea = function(height) {
    let left = 0, right = height.length - 1;
    let ans = 0;
    while(left < right){
        let area = Math.min(height[left],height[right])*(right - left); //每次计算出容量
        ans = Math.max(ans,area);//更新最大值
        if(height[left] <= height[right]){
            left++;
        }else{
            right--;
        }
    }
    return ans;
};

15. 三数之和

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例 2：

输入：nums = []
输出：[]

示例 3：

输入：nums = [0]
输出：[]

题解思路

  • 首先对数组进行排序
  • 固定一个第一个数，然后后两个数使用双指针，因为数组此时是按顺序排的，所以如果和大于0，那就右指针向左移。
  • 另外，在每次固定第一个指针时的循环中，我们可以进行剪枝操作
    • 如果遇见相同的数，直接continue
    • 如果固定的第一个数大于0，直接break跳出循环，因为数组是有序的，后面的数一定比前面的大，那么永远不可能为0
var threeSum = function(nums) {
    let ans = [];
    const len = nums.length;
    if(len < 3) return ans;
    nums.sort((a,b) => a - b);
    for(let i = 0; i < len; i++){
        if(nums[i] > 0) break;
        if(i > 0 && nums[i] == nums[i-1]) continue;
        let left = i + 1;
        let right = len - 1;
        while(left < right){
            let sum = nums[i] + nums[left] + nums[right];
            if(sum === 0){
                ans.push([nums[i],nums[left],nums[right]]);
                while(left < right && nums[left] === nums[left + 1]) left++;
                while(left < right && nums[right] === nums[right - 1]) right--;
                left++;
                right--;
            }
            else if(sum < 0) left++;
            else if(sum > 0) right--;
        }
    }
    return ans;
};

16. 最接近的三数之和

16. 最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2

解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
示例 2：

输入：nums = [0,0,0], target = 1
输出：0

题解思路

  • 和第十五题相似，也是固定第一个数，双指针指向下一个数和最后一个数
  • 首先需要对数组进行排序
  • 用变量res来存储最终的答案
  • 每次比较当前的绝对值和res中的决定值，并更新结果
  • 如果相同，就返回，不必再比较了
var threeSumClosest = function(nums, target) {
    let res = Number.MAX_SAFE_INTEGER;
    nums.sort((a,b) => a - b);
    let len = nums.length;
    for(let i = 0; i < len; i++){
        let left = i + 1, right = len - 1;
        while(left < right){
            let sum = nums[i] + nums[left] + nums[right];
            if(Math.abs(sum - target) < Math.abs(res - target)){
                res = sum;
            }
            if(sum < target){
                left++;
            }else if(sum > target){
                right--;
            }else{
                return sum;
            }
        }
    }
    return res;
};

18. 四数之和

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]]

题解思路

  • 循环前两个数，后两个数使用双指针

  • 首先对数组排序

  • 可以进行剪枝：

    • if(i > 0 && nums[i] === nums[i-1]) continue;
//如果当前最小的和比目标值大，那就结束循环，因为数组有序，后面的和一定更大
if(nums[i] + nums[i+1] + nums[i+2] + nums[i+3] > target) break;
//如果当前的最大的和比目标值还小，那就直接跳过这个要循环的数
if(nums[i] + nums[len-1] + nums[len-2] + nums[len-3] < target) continue;

  • 在while循环中，要根据sum和target的大小，左右移动指针，并且因为可以出现同样的数，所以要排除掉相同的数

    • while(left < right){
	if(nums[left] !== nums[++left]) break;
}

完整代码

var fourSum = function(nums, target) {
  let res = [];
  let len = nums.length;
  if(len < 4) return [];
  nums.sort((a,b) => a - b);
  for(let i = 0; i < len - 3; i++){
    if(i > 0 && nums[i] === nums[i-1]) continue;
    if(nums[i] + nums[i+1] + nums[i+2] + nums[i+3] > target) break;
    if(nums[i] + nums[len-1] + nums[len-2] + nums[len-3] < target) continue;
    for(let j = i + 1; j < len - 2; j++){
      if(j > i + 1 && nums[j] === nums[j-1]) continue;
      if(nums[i] + nums[j] + nums[j+1] + nums[j+2] > target) break;
      if(nums[i] + nums[j] + nums[len-1] + nums[len-2] < target) continue;
      let left = j+1, right = len-1;
      while(left < right){
        let sum = nums[i] + nums[j] + nums[left] + nums[right];
        if(sum === target){
          res.push([nums[i], nums[j], nums[left], nums[right]]);
          while(left < right && nums[left] === nums[left+1]){
            left++;
          }
          while(left < right && nums[right] === nums[right-1]){
            right--;
          }
          left++;
          right--;
        } else if(sum > target){
          while(left < right){
            if(nums[right] !== nums[--right]) break;
          }
        } else if(sum < target){
          while(left < right){
            if(nums[left] !== nums[++left]) break;
          }
        }
      } 
    }
  }
  return res;
};

42. 接雨水

42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

在这里插入图片描述

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

题解思路

  • 这里我们按照求每一列的雨水，最后将每一列的雨水加起来

  • 对于当前要求的这一列，设两个指针，从当前列向两边走，分别求出两侧最高的列

  • 此时就要分情况讨论

    • 当正在求的列是最矮的，此时就可以计算

      在这里插入图片描述

    • 当正在求的列不是最矮的，那么就无法盛到水

      在这里插入图片描述

      在这里插入图片描述

var trap = function(height) {
    let sum = 0;
    for(let i = 0; i < height.length; i++){//遍历每一列，求出每一列可以存储的水
        if(i == 0 || i == height.length - 1) continue; //跳过最左边和最右边的列
        let lHeight = height[i], rHeight = height[i];
        for(let r = i + 1; r < height.length; r++){//右边的指针
            if(height[r] > rHeight) rHeight = height[r];//拿到右边最高的列
        }
        for(let l = i - 1; l >= 0; l--){
            if(height[l] > lHeight) lHeight = height[l];//拿到左边最高的列
        }
        let h = Math.min(lHeight,rHeight) - height[i];//计算两边列的最小值与要求的当前列的差值
        if(h > 0) sum += h;//当差值大于0，即当前要求的列是最矮的
    }
    return sum;
};

167. 两数之和 II - 输入有序数组

167. 两数之和 II - 输入有序数组

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

题解

  • 设置两个指针，指向数组的开头和结尾
  • 因为数组是有序的，那么每次计算出两个指针的和，如果计算出的结果偏大，那么右指针向左移…
  • 如果相等，返回指针下标+1
var twoSum = function(numbers, target) {
    let i = 0, j = numbers.length - 1;
    while(i < j){
        let sum = numbers[i] + numbers[j];
        if(sum > target){
            j--;
        }else if(sum < target){
            i++;
        }else{
            return [i+1,j+1];
        }
    }
};

283. 移动零

283. 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

题解

  • 两个指针都指向数组的开始
  • 实现移动0的思想就是：将慢指针指向新生成的那个数组的末尾，快指针负责扫描原数组
  • 如果快指针扫到了非0 的数，并且快慢指针不重合，那就交换快慢指针的数
  • 如果快慢指针重合，此时不用交换，另外因为这个数非0，那么慢指针向后移动，表示将这个数加入新数组
var moveZeroes = function(nums) {
    let slow = 0, fast = 0;
    while(fast < nums.length){
        if(nums[fast]){//扫到了非0的数
            if(fast !== slow){
                let temp = nums[slow];
                nums[slow] = nums[fast];
                nums[fast] = temp;
            }
            slow++;//在这个if条件中，说明扫到了非0的数，那么慢指针+1，因为慢指针要指向新数组的末尾
        }
        fast++;//快指针负责扫描原数组，所以每次向后移动
    }
};

344. 反转字符串

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

题解

var reverseString = function(s) {
    let i = 0, j = s.length - 1;
    let temp = '';
    while(i < j){
        temp = s[i];
        s[i] = s[j];
        s[j] = temp;
        i++;
        j--;
    }
};

345. 反转字符串中的元音字母

345. 反转字符串中的元音字母

给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。

元音字母包括 ‘a’、‘e’、‘i’、‘o’、‘u’，且可能以大小写两种形式出现。

示例 1：

输入：s = "hello"
输出："holle"

示例 2：

输入：s = "leetcode"
输出："leotcede"

题解

  • 将字符串转换成数组
  • 两个指针指向开头和结尾
  • 设置循环条件为两个指针相撞时退出
  • 如果 i指针 是元音字母，进入if循环，判断 j指针是否是元音字母，如果是，交换，否则，如果 j指针不是元音字母，j指针左移
  • 如果 i指针 不是元音字母，i指针 右移
  • 最后将数组拼接成字符串返回
var reverseVowels = function(s) {
    let vowels = ['a','e','i','o','u','A','E','I','O','U'];
    let i = 0, j = s.length - 1;
    let arr = s.split('');
    while(i < j){
        if(vowels.includes(arr[i])){
            if(vowels.includes(arr[j])){
                let temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                i++;
                j--;
            }else {
                j--;
            }
        }else{
            i++;
        }
    }
    return arr.join('');
};

844. 比较含退格的字符串

844. 比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

题解

  • 因为题目中说如果出现#，那么它前面的字符退格。那么我们就可以从后往前遍历字符串，并且设置标志边量用来记录是否遇见#
  • 如果遇见#，指针向左移动一位，并且用标志变量记录
  • 如果遇见普通字符并且标志变量存在，那么指针向左移动一位，表示退格，并且消除标志变量
  • 否则如果遇见普通字符但没有标志变量，那就退出循环，比较两个指针指向的字符
var backspaceCompare = function(s, t) {
    let i = s.length - 1, j = t.length - 1;
    let skipS = 0, skipT = 0;//标志变量
    while(i >= 0 || j >= 0){
        while(i >= 0){
            if(s[i] === '#'){
                skipS++;
                i--;
            }else if(skipS > 0){
                i--;
                skipS--;
            }else break;
        }
        while(j >= 0){
            if(t[j] === '#'){
                skipT++;
                j--;
            }else if(skipT > 0){
                skipT--;
                j--;
            }else break;
        }
        if(s[i] !== t[j]) return false;
        i--;
        j--;
    }
    return true;
};

881. 救生艇

881. 救生艇

给定数组 people 。people[i]表示第 i 个人的体重 ，船的数量不限，每艘船可以承载的最大重量为 limit。

每艘船最多可同时载两人，但条件是这些人的重量之和最多为 limit。

返回 承载所有人所需的最小船数 。

示例 1：

输入：people = [1,2], limit = 3
输出：1
解释：1 艘船载 (1, 2)

示例 2：

输入：people = [3,2,2,1], limit = 3
输出：3
解释：3 艘船分别载 (1, 2), (2) 和 (3)

示例 3：

输入：people = [3,5,3,4], limit = 5
输出：4
解释：4 艘船分别载 (3), (3), (4), (5)

题解

  • 注意审题，题目中说明，一艘船只允许最多载两个人
  • 两个指针指向开始和末尾
  • 如果 people[left] + people[right] <= limit ：说明 left 和 right 指向的人可以配对（乘坐同一艘船），此时 left 和 right 各向中间走一步；
  • 如果 people[left] + people[right] > limit ：说明 right 指向的人太重了，他应该单独乘坐一艘船。即 right 向中间走一步（right--）。

按照上面的方式，直到 left 与 right 重合，这样就可以完成任务。

  • 注意，while循环退出的条件是 left === right，那么此时left指针执行的人还未坐船，那么应该再加上一艘船
var numRescueBoats = function(people, limit) {
    if(people.length === 0) return 0;
    people = people.sort((a,b) => a - b);
    let left = 0, right = people.length - 1;
    let nums = 0;
    while(left < right){
        if(people[left] + people[right] <= limit){
            left++;
            right--;
        }else{
            right--;
        }
        nums++;
    }
    if(left === right) nums++;//此时left指针执行的人还未坐船，那么应该再加上一艘船
    return nums;
};

977. 有序数组的平方

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]

题解

  • 因为数组有序，那么两边的数平方后的值最大，中间的数平方后的值较小
  • 两个指针分别指向数组的开头与结尾，然后求出平方，将比较后的较大值放入数组的开头
  • 因为两个指针是向中间走的，那么所求的平方值也应该是越来越小，所以应该插入到数组的最前面
var sortedSquares = function(nums) {
    let res = [];
    let i = 0, j = nums.length - 1;
    while(i <= j){
        let left = Math.abs(nums[i]);
        let right = Math.abs(nums[j]);
        if(right > left){
            res.unshift(right * right);
            j--;
        }else{
            res.unshift(left * left);
            i++;
        }
    }
    return res;
};
程序媛小y
关注
专栏目录
java-leetcode面试题解双指针之第977题有序数组的平方.zip
03-25
本资源“java_leetcode面试题解双指针之第977题有序数组的平方”聚焦于解决LeetCode上的第977题，这是一道与双指针技术和有序数组相关的算法问题。下面我们将深入探讨这个题目及其解决方案。 **题目描述：** ...
LeetCode双指针经典题（一）15道
CodePanda@GPF的博客
04-28 1988
LeetCode双指针类型题目
LeetCode刷题——巧用双指针
ha_lee的博客
07-03 611
双指针类型LeetCode刷题笔记
《算法-入门-C++》第2天 双指针
heart_6662的博客
12-02 765
目录 977. 有序数组的平方[LeetCode] 方法一：暴力解法 方法二：双指针 ​ 189. 轮转数组LeetCode 三次翻转 大佬写法： 我的写法： 977. 有序数组的平方 [LeetCode] 题目：给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序 方法一：暴力解法 for循环加快速排序 class Solution { public: vector<int> s...
双指针窗口题目(简单)
zkf1122334的博客
04-17 253
1.Pair with Target Sum (easy) 问题描述 给定一个排序数字数组和一个目标总和，在数组中找到一个总和等于给定目标的对。 编写一个函数来返回两个数字（即对）的索引，以便它们相加到给定的目标。 Example 1: Input: [1, 2, 3, 4, 6], target=6 Output: [1, 3] Explanation: The numbers at index 1 and 3 add up to 6: 2+4=6 Example 2: Input: [2, 5, 9,
LeetCode算法题2：双指针
Little_ant_的博客
02-24 7718
一、有序数组的平方 二、轮转数组 三、移动零 四、两数之和 II - 输入有序数组 五、反转字符串 六、反转字符串中的单词 III 七、链表的中间结点 八、删除链表的倒数第 N 个结点
java-leetcode面试题解双指针之第925题长按键入.zip
最新发布
03-25
这个题目涉及到双指针技术，这是一种在数组或字符串处理中广泛使用的优化技巧。 双指针是一种在处理线性数据结构时非常有效的策略，它通常涉及两个指针，分别从数组或字符串的两端开始，向中间移动，以实现查找、...
java-leetcode面试题解双指针之第42题接雨水.zip
03-25
其中，第42题“接雨水”是双指针技术的一个经典应用，这道题目旨在考察程序员对数组处理、动态规划以及双指针技巧的理解。 双指针是一种常见的算法思想，它通过维护两个指针（通常一个从数组的起始位置开始，另一个...
java-leetcode面试题解双指针之第125题验证回文串.zip
03-25
以上就是关于Java LeetCode面试题解双指针之第125题验证回文串的详细解析，包括问题描述、解题思路、代码实现以及相关的知识点拓展。这个题目不仅测试了基础的字符串操作，还考察了对双指针技巧的理解和应用，是Java...
java-leetcode面试题解双指针之第15题三数之和.zip
03-25
本压缩包文件“java-leetcode面试题解双指针之第15题三数之和.zip”包含了解决这道问题的Java代码实现。 题目描述：给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a，b，c，使得a + b + c = 0？要求找...
LeetCode--双指针经典题目解析汇总
数据挖掘+大数据研发+算法学习
12-31 289
后续补充，先完成目录
Leetcode 双指针算法题目详解
wwxy1995的博客
08-19 231
167.Two Sum II - Input array is sorted Easy 1019423FavoriteShare Given an array of integers that is alreadysorted in ascending order, find two numbers such that they add up to a specific target n...
算法刷题——双指针（1）
weixin_54510792的博客
05-14 143
自从昨天结束数模校赛和概率论期中考试之后，发现突然一下子闲下来了呢。虽然虽然还有很多想学的知识没有学，但是一不小心惫懒的情绪就从心底蔓延开了。 咳咳咳，言归正传，今天学习的算法还是双指针。通过刷题我也发现了双指针是真的强大，在一些题目中使用双指针的话，往往可以把时间复杂度降为O（n），空间复杂度也只是O（1）级别的。 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
指向指针的指针
Protinx的博客
02-12 290
C语言用指向指针的指针的方法对n个整数排序并输出；要求将排序单独写成一个函数；n个整数在主函数中输入，最后在主函数中输出。 C语言源代码演示： #include<stdio.h>//头文件 int main()//主函数 { void sort(int **point,int number); //sort排序函数声明 int i,number,data[20],**point,*pstr[20]; //定义变量 printf("输入要排序的个数number：");//提示语句
牛客 剑指offer_编程题 详细题解 （已完结）
weixin_44211980的博客
01-31 4588
文章目录剑指offer_编程题【1.二维数组中的查找】【2.替换空格】C++JAVA【3.从尾到头打印链表】【4.重建二叉树】【5.用两个栈实现队列】【6.旋转数组的最小数字】暴力Sort二分法【7.斐波那契数列】【8.跳台阶】【9.变态跳台阶】 剑指offer_编程题 【1.二维数组中的查找】 【题目描述】 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都...
【数组专题】—— 双指针
欢迎来到我的世界
03-22 317
一份简单的快乐!
算法技巧总结（一）双指针
一包辣条包邮！的博客
10-19 541
序言： 最近刷算法题时发现有的题目要求是：不要使用额外数组空间，必须在原地修改输入数组，并在使用O(1)额外的条件完成。 这对于常规的采用循环甚至双循环的方法来说空间开销就很大，而且题设要求不能开辟更多的空间，只能再原来的内存空间进行修改。因此，双指针法（双下标法）的用处就体现出来了。 那什么是双指针算法呢？？？ 双指针算法其实就是初始化两个指针，一个指向数组的首位置元素，另外一个指向数组的末尾的位置元素，然后根据自定义需求条件进行两指针的移动，最后是找到两个满足条件的数或者不存在这样的两个数字，.
LeetCode双指针算法总结1
CS_boy的博客
03-04 598
双指针算法是一类依靠单调性来去除结果的算法。
LeetCode双指针与哈希技巧解决面试高频题
- 题目要求通过双指针法实现字符串s的反转。定义两个指针i和j，初始时i指向字符串开头，j指向结尾。当i小于j时，交换s[i]和s[j]的值，直到i和j相遇。此操作体现了数组操作的基本技巧，用于处理字符串或数组的对称...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序媛小y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值