算法| ss 双指针

已于 2024-04-08 17:51:51 修改
阅读量318 收藏
点赞数 3
文章标签： 算法
于 2024-04-06 23:12:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shjavadown/article/details/137441244
版权
  • 11.盛水最多的容器
  • 15.三数之和
  • 18.四数之和
  • 26.删除有序数组中的重复项
  • 27.移除元素
  • 75.颜色分类
  • 88.合并两个有序数组
  • 167.两数之和2-输入有序数组
  • 581.最短无序连续子数组
  • 2486.追加字符以获得子序列
  • 792.匹配子序列的单词数

11.盛水最多的容器

/**
 * @param {number[]} height
 * @return {number}
 */
// 思路
// 左0 右 n-1
// while left<right
// 计算宽度right-left
// 左边大： 右高乘以width  右--
// 右边大： 左高乘以width 左++
// 指针移动： 谁小谁移动
// 更新最大值
var maxArea = function (height) {
  let left = 0;
  let right = height.length - 1;
  let ans = 0;
  while (left < right) {
    let width = right - left;
    if (height[left] > height[right]) {
      val = width * height[right];
      ans = Math.max(ans, val);
      right -= 1;
    } else {
      val = width * height[left];
      ans = Math.max(ans, val);
      left += 1;
    }
  }
  console.log(ans);
};
maxArea([1, 8, 6, 2, 5, 4, 8, 3, 7]);
// 输入：[1,8,6,2,5,4,8,3,7]
// 输出：49

15.三数之和

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
// 思路
//  数组升序（很重要）
// 计算公式：  定个首元素  +  左元素 + 右元素 = 0
// for循环定义首元素
// while循环 变更左右指针， 确定左右元素
// total <0 left++  total> 0 rigth++
// total==0 更新结果， 并且剪枝 如果左==左+1  左++   右=右-1 右--
var threeSum = function (nums) {
  nums.sort((a, b) => a - b);
  let ans = [];
  for (let i = 0; i < nums.length; i++) {
    let startNum = nums[i];
    let left = i + 1;
    let right = nums.length - 1;
    if (startNum > 0) continue;
    if (i > 0 && startNum === nums[i - 1]) continue;
    while (left < right) {
      let total = startNum + nums[left] + nums[right];
      if (total < 0) {
        left += 1;
      } else if (total > 0) {
        right -= 1;
      } else {
        ans.push([startNum, nums[left], nums[right]]);
        // 剪枝避免重复元素
        while (left < right && nums[left] === nums[left + 1]) left += 1;
        while (left < right && nums[right] === nums[right - 1]) right -= 1;
        left += 1;
        right -= 1;
      }
    }
  }
  //   console.log("ans", ans);
  return ans;
};
// [ -4, -1, -1, 0, 1, 2 ]
threeSum([-1, 0, 1, 2, -1, -4]);

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

18.四数之和

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[][]}
 */
// 思路； 双for循环 确定两个数， 再用 双指针方法确定另外两个数
var fourSum = function (nums, target) {
  const len = nums.length;
  if (len < 4) return [];
  nums.sort((a, b) => a - b);
  const res = [];
  for (let i = 0; i < len - 3; i++) {
    // 去重
    if (i > 0 && nums[i] === nums[i - 1]) continue;
    // j的起始值要比i大1
    for (let j = i + 1; j < len - 2; j++) {
      // 去重
      if (j > i + 1 && nums[j] === nums[j - 1]) continue;
      let left = j + 1;
      let right = len - 1;

      while (left < right) {
        let sum = nums[i] + nums[j] + nums[left] + nums[right];
        if (sum < target) {
          left++;
          continue;
        }
        if (sum > target) {
          right--;
          continue;
        }
        res.push([nums[i], nums[j], nums[left], nums[right]]);
        // 剪枝避免重复元素
        while (left < right && nums[left] === nums[left + 1]) left += 1;
        while (left < right && nums[right] === nums[right - 1]) right -= 1;
        left += 1;
        right -= 1;
      }
    }
  }
  console.log(res);
};
fourSum([1, 0, -1, 0, -2, 2], 0);
fourSum([2, 2, 2, 2, 2], 8);
// 示例 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]]

26.删除有序数组中的重复项

/**
 * @param {number[]} nums
 * @return {number}
 */
// 思路
// 双指针解法
// for循环 right从1开始
// 当left right对应的值不相等时， left递增1， 并且对应值赋值为right对应的值
var removeDuplicates = function (nums) {
  let left = 0;
  for (let right = 1; right < nums.length; right++) {
    if (nums[left] !== nums[right]) {
      left += 1;
      nums[left] = nums[right];
    }
  }
  console.log(left + 1);
  return left + 1;
};
removeDuplicates([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]);

27.移除元素

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
// 思路
// 双指针解法
// for遍历数组
// 条件: 当遍历值不等于val时, 设置num[i]为遍历值，并指针右移
// 都是不利用任何api，只是更改数组下标的方式得到结果
var removeElement = function (nums, val) {
  let i = 0;
  for (let j = 0; j < nums.length; j++) {
    if (nums[j] !== val) {
      nums[i] = nums[j];
      i += 1;
    }
  }
  return i;
};
removeElement([3, 2, 2, 3], 3);
// nums = [3,2,2,3], val = 3

75.颜色分类

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
// 思路 双指针
// 定义三个指针 左中右
// while index <= right
// index值==0  index 和left交换 index++ left++
// index值==2  right--
// index值-1 index++
var sortColors = function (nums) {
  // 定义
  let index = 0;
  let left = 0;
  let right = nums.length - 1;
  while (index <= right) {
    // index只有在值为0和1的情况下才进行右移
    const cur = nums[index];
    // index 和left交换
    if (cur === 0) {
      nums[index] = nums[left];
      nums[left] = cur;
      left += 1;
      index += 1;
      // index 继续右移
    } else if (cur === 1) {
      index += 1;
      // index 和right 交换
    } else if (cur === 2) {
      nums[index] = nums[right];
      nums[right] = cur;
      right -= 1;
    }
  }
};
// 示例 1：

// 输入：nums = [2,0,2,1,1,0]
// 输出：[0,0,1,1,2,2]
// 示例 2：

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

88.合并两个有序数组

/**
 * @param {number[]} nums1
 * @param {number} m
 * @param {number[]} nums2
 * @param {number} n
 * @return {void} Do not return anything, modify nums1 in-place instead.
 */
// 思路
// 定义两个数组的尾指针
// whiile 循环比较尾指针值大小
// 分别填充比较后的数值， 指针左移
// for循环nums2  填充， 补充前面的数据（针对num2的长度比num1长）
var merge = function (nums1, m, nums2, n) {
  let firstPoint = m - 1;
  let secondPoint = n - 1;
  //   倒序 从尾部比较2个数组，填充， 指针左移
  while (firstPoint >= 0 && secondPoint >= 0) {
    if (nums1[firstPoint] > nums2[secondPoint]) {
      nums1[firstPoint + secondPoint + 1] = nums1[firstPoint];
      firstPoint -= 1;
    } else {
      nums1[firstPoint + secondPoint + 1] = nums2[secondPoint];
      secondPoint -= 1;
    }
  }
  //   num1比num2短的情况下
  if (secondPoint >= 0) {
    for (let i = 0; i < secondPoint; i++) {
      nums1[i] = nums2[i];
    }
  }
};

// 输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
// 输出：[1,2,2,3,5,6]
// 解释：需要合并 [1,2,3] 和 [2,5,6] 。
// 合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

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

/**
 * @param {number[]} numbers
 * @param {number} target
 * @return {number[]}
 */
// 思路
// 定义头尾双指针
// while i < j
//   分三种情况处理， > j--  < i++ = 返回结果
var twoSum = function (numbers, target) {
  // 定义头尾双指针
  let i = 0;
  let j = numbers.length - 1;
  // 定义结果
  res = [0, 0];
  // 循环
  while (i < j) {
    // 两者相加相等 返回结果
    if (numbers[i] + numbers[j] === target) {
      res[0] = i + 1;
      res[1] = j + 1;
      // 返回结果
      return res;
    }
    // 两者相加小于结果， i 向右移动
    else if (numbers[i] + numbers[j] < target) {
      i += 1;
    }
    // 两者相加大于结果， j 向左移动
    else {
      j -= 1;
    }
  }
  return res;
};

581. 最短无序连续子数组

/**
 * @param {number[]} nums
 * @return {number}
 */
// 思路： 双指针解法
// while循环 从左 从右遍历 找到 left right边界
// for循环left right 找到其中的最大值 最小值
// 确定左右指针的最终位置， left比min小  max 比right小
// 更新结果 right-left -1

var findUnsortedSubarray = function (nums) {
  let len = nums.length;
  let left = 0;
  let right = len - 1;
  while (left < len && nums[left] <= nums[left + 1]) left++;
  while (right >= 0 && nums[right - 1] <= nums[right]) right--;
  let min = Infinity;
  let max = -Infinity;
  for (let i = left; i <= right; i++) {
    min = Math.min(min, nums[i]);
    max = Math.max(max, nums[i]);
  }
  while (nums[left] > min) left--;
  while (nums[right] < max) right++;
  console.log(left, right);
  return left < right ? right - left - 1 : 0;
};
console.log(findUnsortedSubarray([2, 6, 4, 8, 10, 9, 15]));
console.log(findUnsortedSubarray([1, 3, 2, 2, 2]));
// 输入：nums = [2,6,4,8,10,9,15]
// 输出：5

2486. 追加字符以获得子序列

/**
 * @param {string} s
 * @param {string} t
 * @return {number}
 */
// 思路
// 双指针解法
// 遍历字符串s , 如果s某个字符等于t的某个字符，则i++
// 更新结果n-i
var appendCharacters = function (s, t) {
  const n = t.length;
  let i = 0;
  for (let j = 0; j < s.length; j++) {
    if (s[j] === t[i]) {
      i++;
    }
  }
  console.log(n - i);
  return n - i;
};
appendCharacters("coaching", "coding");
// 输入：s = "coaching", t = "coding"
// 输出：4

792.匹配子序列的单词数

/**
 * @param {string} s
 * @param {string[]} words
 * @return {number}
 */
var numMatchingSubseq = function (s, words) {
  let ans = 0;
  for (let word of words) {
    if (check(word, s)) {
      ans += 1;
    }
  }
  console.log(ans);
  return ans;
  function check(word) {
    let j = 0;
    for (let i = 0; i < word.length; i++) {
      // indexOf  第二个参数： 从哪个位置开始
      j = s.indexOf(word[i], j);
      if (j === -1) return false;
      j += 1;
    }
    return true;
  }
  //   下面思路会超时
  //   function check(word) {
  //     let left = 0;
  //     for (let ch of s) {
  //       if (ch === word[left]) {
  //         left += 1;
  //       }
  //     }
  //     // console.log("left", word, left);
  //     if (left === word.length) return true;
  //     return false;
  //   }
};
numMatchingSubseq("abcde", ["a", "bb", "acd", "ace"]);
// 输入: s = "abcde", words = ["a","bb","acd","ace"]
// 输出: 3
shjavadown
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
有关双指针的简单算法题
yaoyao071500的博客
03-11 1944
有关双指针 1. 移动零（附leetcode.283） 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 方法一:双指针 思路： 使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。 右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。 注意到以下性质： 1.左指针左边均为非零数； 2.右指针左边直到左指针处均为零。 因此每次交
LeetCode算法题2：双指针
Little_ant_的博客
02-24 7446
一、有序数组的平方 二、轮转数组 三、移动零 四、两数之和 II - 输入有序数组 五、反转字符串 六、反转字符串中的单词 III 七、链表的中间结点 八、删除链表的倒数第 N 个结点
算法 反转自符串-(双指针)
Neil的博客
09-25 85
反转字符串
c++算法之双指针
weixin_63201442的博客
01-19 865
双指针算法是一种常用的算法技巧，它通常用于在数组或字符串中进行快速查找、匹配、排序或移动操作双指针并非真的用指针实现，一般用两个变量来表示下标(在后面都用指针来表示)双指针算法使用两个指针在数据结构上进行迭代，并根据问题的要求移动这些指针。双指针往往也和单调性、排序联系在一起，在数组的区间问题上，暴力法的时间复杂度往往是O(n^2)的，但双指针利用“单调性”可以优化到O(n)。常见的双指针有：对撞指针和快慢指针。
LeetCode 算法入门 Day4 双指针 Java
TIANJIAWEN的博客
11-15 254
344.反转字符串 问题描述: 解答: class Solution { public void reverseString(char[] s) { int len=s.length,low=0,high=s.length-1; while(low<high){ char ss=s[low]; s[low]=s[high]; s[high]=ss; lo.
双指针算法应用方式介绍
01-14
双指针算法
适合小白的python算法-双指针问题
12-21
python算法-双指针问题一、数组合并1. 使用模拟指针和并两个有序数组2.模拟指针说明：二、二分法（折半查找法）1.有序数组的二分法查找2. 二分法说明三、链表（双链表和单链表区别） 一、数组合并 1. 使用模拟指针和...
双指针算法经典问题详解
01-14
《双指针算法经典问题详解资料，包含代码实现》是一本针对双指针算法在经典问题中的应用指南。本资料深入浅出地解析了双指针算法的基本原理和核心思想，并通过丰富的案例和实际代码，帮助读者理解如何运用双指针算法...
双指针算法.txt-双指针
01-14
双指针算法
笔试强训-day17_T2 十字爆破
weixin_46186903的博客
05-03 465
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 189
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
Python机器学习项目开发实战：在数据分析竞赛平台遴选最佳算法模型
最新发布
一个好知识的传播者
05-03 991
在Python机器学习项目开发实战中，数据分析竞赛平台为我们提供了一个实践和验证算法模型性能的理想场所。在这些平台上，参赛者需要面对各种真实世界的数据集，通过选择和应用合适的算法模型，来解决各种复杂的数据分析问题。下面将详细阐述如何在数据分析竞赛平台上遴选最佳的算法模型。
leetcode16-3Sum Closest
我的程序人生
04-29 311
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 648
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
代码随想录算法训练营第三十八天
weixin_41902984的博客
04-28 253
又又又欠两天债，不过回家了，一切可以按部就班，明天慢慢补吧，今天先做一课的内容。然后就是如果一次可以上m个阶梯的话应该怎么做，先把伪代码放上来。其实就是斐波那契数，不过需要理解一下过程。还好还好，动态规划第一天不太难。746. 使用最小花费爬楼梯。509. 斐波那契数。
Golang | Leetcode Golang题解之第56题合并区间
weixin_66442839的博客
04-28 553
Golang | Leetcode Golang题解之第56题合并区间
第六章 图
qq_44419734的博客
04-27 653
带权有向图中，顶点表示事件，有向边表示活动，边上的权值表示完成该活动的开销（如完成活动所需要的时间），称之为用边表示活动的网络。
c入门基础题（3）
梦昼初
04-26 962
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
【算法刷题 | 贪心算法08】4.29（划分字母区间、合并区间）
踢桃的成长之路
04-29 647
4.29（划分字母区间、合并区间）
python 双指针算法
09-16
双指针算法是一种常用的算法技巧，在解决一些数组或链表相关的问题时特别有用。它通过使用两个指针来追踪数组或链表中的元素，通常有以下几种常见的应用场景： 1. 快慢指针：快指针每次移动两步，慢指针每次移动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值