双指针 （doublePointer）

最新推荐文章于 2024-04-06 15:12:47 发布
最新推荐文章于 2024-04-06 15:12:47 发布
阅读量1k 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43156699/article/details/118854295
版权
本文详细介绍了使用双指针解决数组和字符串问题的多种经典算法，包括寻找三数之和、最长回文子串、最长有效括号、盛最多水的容器、接雨水、反转字符串和下一个排列等。通过实例分析，展示了双指针在解决这些复杂问题时的高效性和简洁性。
摘要由CSDN通过智能技术生成

双指针 （doublePointer）

1 双指针

1.1 (lee-15) 三数之和

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

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

/**
	 * 思路：双指针
	 * 1.首先，特例判断，如果数组为null或者数组长度小于3，返回null;
	 * 2.对数组进行排序，因为要求不能包含可以重复的三元组，因此排序后再操作;
	 * 3.对数组进行遍历：
	 *       如果nums[i] > 0,说明已经排好序，后面不会有三数相加和=0,直接返回结果;
	 *       对于重复元素，跳过，避免出现重复解;
	 *       令左指针为L，右指针为R，使用双指针法进行遍历。
	 * 时间复杂度：O(n^2)   
	 * 空间复杂度：O(n) 
	 * @param nums
	 * @return
	 */
	public List<List<Integer>> threeSum(int[] nums) {
		List<List<Integer>> res = new ArrayList<>();
		int n = nums.length;
		Arrays.sort(nums);
		for(int i = 0;i <n;i++) {
			if(nums[i] > 0) {                            // 后面的元素肯定不满足要求，都是大于0的
				return res;
			}
			if(i > 0 && nums[i] == nums[i-1]) {          // 遇到重复的跳过
				continue;
			}
			int left = i+1;
			int right = n-1;
			int cur = nums[i];
			while(left < right) {
				int temp = cur + nums[left] + nums[right];
				if(temp == 0) {
					List<Integer> list = Arrays.asList(cur,nums[left],nums[right]);
					res.add(list);
					 // 剔除重复元素
					while(left < right && nums[left+1] == nums[left]) {
						left++;
					}
					while(left < right && nums[right-1] == nums[right]) {
						right--;
					}
					// 同时移动left、right
					left++;
					right--;
				}else if(temp < 0) {
					left++;                               // 说明left太小，left右移
				}else {
					right--;                              // 说明right太大，right左移
				}
			}
		}
		return res;
    }

1.2 (lee-05) 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案

（1） DP

	/**
	 * 1.DP 
	 * 状态转移方程：P(i,j)=P(i+1,j−1)∧(Si​==Sj​)
	 * 边界条件：
	 * P(i,i)=true 子串的长度为1
	 * P(i,i+1)=(Si​==Si+1​) 子串的长度为2
	 * 答案: 子串长度最大值 j-i+1
	 * 
	 * 时间复杂度：O(n^2)
	 * 空间复杂度：O(n^2)​
	 * @param s
	 * @return
	 */
	public String longestPalindrome1(String s) {
		int len = s.length();
		if(len < 2) {
			return s;
		}
		int maxLen = 1;
		int start = 0;
		boolean[][] dp = new boolean[len][len]; // dp[i][j] 表示 s[i..j] 是否是回文串
		for(int i = 0;i <len;i++) {             // 初始化：所有长度为 1 的子串都是回文串
			dp[i][i] = true;
		}
		char[] c = s.toCharArray();
		for(int L = 2;L <= len;L++) {            // 先枚举子串长度
			for(int i = 0; i < len;i++) {        // 枚举左边界，左边界的上限设置可以宽松一些
				int j = L+i-1;                   // 由 L 和 i 可以确定右边界
				if(j >= len) {                   // 如果右边界越界，就可以退出当前循环
					break;
				}
				if(c[i] != c[j]) {
					dp[i][j] = false;
				}else {
					if(j - i < 3) {
						dp[i][j] = true;
					}else {
						dp[i][j] = dp[i+1][j-1];
					}
				}
				
				// 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
				if(dp[i][j] && j-i+1 > maxLen) {
					maxLen = j-i+1;
					start = i;
				}
			}
		}
		return s.substring(start , start+maxLen);
	}

（2） 双指针

	/**
	 * 2.思路：双指针，注意奇偶
	 * 遍历每一个索引，以这个索引为中心，利用“回文串”中心对称的特点，往两边扩散，看最多能扩散多远。
	 * 回文串在长度为奇数和偶数的时候，“回文中心”的形式是不一样的。
	 * left = right 的时候，此时回文中心是一个字符，回文串的长度是奇数
	 * left + 1 = right 的时候，此时回文中心是一个空隙，回文串的长度是偶数
	 * 时间复杂度：O(n^2)
	 * 空间复杂度：O(1)
	 * @param s
	 * @return
	 */
	public String longestPalindrome(String s) {
		int len = s.length();
		if(len < 2) {
			return s;
		}
		int maxLen = 1;
		String res = s.substring(0,1);
		
		for(int i = 0;i < len - 1;i++) {
			String oddStr = centerSpread(s,i,i);
			String eveStr = centerSpread(s,i,i+1);
			String maxLenStr = oddStr.length() > eveStr.length() ? oddStr : eveStr;
			if(maxLenStr.length() > maxLen) {
				maxLen = maxLenStr.length();
				res = maxLenStr;
			}
		}
		return res;
    }

	private String centerSpread(String s, int left, int right) {
		int len = s.length();
		while(left >= 0 && right < len) {
			if(s.charAt(left) == s.charAt(right)) {
				left--;
				right++;
			}else {
				break;
			}
		}
		return s.substring(left+1, right); //这里要注意，跳出 while 循环时，恰好满足 s.charAt(i) != s.charAt(j)，因此不能取（i，j）
	}

1.3 (lee-32) 最长有效括号

给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

输入：s = “(()”
输出：2
解释：最长有效括号子串是 “()”
输入：s = “”
输出：0

（1） 栈

	/**
	 * 1.栈
	 * 思路：利用栈进行括号匹配，每次遇到“(”就入栈，遇到“)”就出栈，为了计算括号的数量，每次当栈空时，将未被匹配的“)”的索引入栈。
	 * 时间复杂度：O(n)
	 * 空间复杂度：O(n)
	 */
	public int longestValidParentheses(String s) {
		Deque<Integer> stack  = new LinkedList<>();
		int maxLen = 0;
		stack.offerFirst(-1);
		char[] c = s.toCharArray();
		for(int i= 0;i < c.length;i++) {
			if(c[i] == '(') {
				stack.offerFirst(i);
			}else {
				stack.pollFirst();
				if(stack.isEmpty()) {
					stack.offerFirst(i);
				}else {
					maxLen = Math.max(maxLen, i-stack.peekFirst());
				}
			}
		}
		return maxLen;
	}

（2） 双指针

	/**
	 * 2.双指针遍历两遍
	 * 思路：从左向右遍历，遇到每个‘(’，left++，遇到每个‘)’，right++; 
	 * 当 left计数器与 right计数器相等时，计算当前有效字符串的长度，并记录目前为止找到的最长子字符串;
	 * 当 right计数器比 left计数器大时，将 left和 right计数器同时变回 0;
	 * 从右往左遍历用类似的方法计算.
	 * 时间复杂度：O(n)
	 * 空间复杂度：O(1)
	 */
	public int longestValidParentheses1(String s) {
		int left = 0;
		int right = 0;
		int maxLen = 0;
		for(int i= 0;i <s.length();i++) {
			if(s.charAt(i) == '(') {
				left++;
			}else {
				right++;
			}
			if(left == right) { 
				maxLen = Math.max(maxLen, 2 * right);
			}else if(right > left) {
				left = right = 0;
			}
		}
		
		left = right = 0;//注意,否则变为二倍
		
		for(int i = s.length() - 1;i >=0;i--) {
			if(s.charAt(i) == '(') {
				left++;
			}else {
				right++;
			}
			if(left == right) {
				maxLen = Math.max(maxLen, 2*left);
			}else if(left > right) {
				left = right = 0;
			}
		}
		return maxLen;
	}

1.4 (lee-11) 盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器，且 n 的值至少为 2。

输入：[1，8，6，2，5，4，8，3，7]
输出：49
该题目与(lee-42)接雨水问题有一点区别，接雨水问题在栈的部分已经总结，包括动态规划、单调栈以及双指针三种方法，这里的求的是构成的整个容器水量，比较简单，使用双指针很快完成。

	/**
	 * (lee-11)
	 * 思路：双指针
	 * 首尾各一个指针，每次向内移动短板，可以得到最大值。
	 * 时间复杂度:O(n)
	 * 空间复杂度：O(1)
	 * @param height
	 * @return
	 */
	public int maxArea(int[] height) {
		int left = 0;
		int right = height.length-1;
		int res = 0;
		while(left < right) {
			if(height[left] < height[right]) {
				res = Math.max(res, (right-left) * height[left]);
				left++;
			}else {
				res = Math.max(res, (right-left) * height[right]);
				right--;
			}
		}
		return res;
    }

1.5 (lee-42) 接雨水

给定 n 个非负整数表示每个宽度为 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 个单位的雨水（蓝色部分表示雨水）。

（1） DP

	/**
	 * 1.动态规划
	 * 时间复杂度O(n)
	 * 空间复杂度O(n)
	 * 需要维护两个数组 leftMax 和 rightMax
	 * @param height
	 * @return
	 */
	public int trap(int[] height) {
		int n = height.length;
		if(n==0) {
			return 0;
		}
		
		int[] leftMax = new int[n];
		leftMax[0] = height[0];
		for(int i = 1;i < n;++i) {
			leftMax[i] = Math.max(leftMax[i-1], height[i]);
		}
		
		int[] rightMax = new int[n];
		rightMax[n-1] = height[n-1];
		for(int i = n-2;i >=0;--i) {
			rightMax[i] = Math.max(rightMax[i+1], height[i]);
		}
		
		int res = 0;
		for(int i= 0;i<n;i++) {
			res += Math.min(leftMax[i], rightMax[i]) - height[i];
		}
		return res;
	}

（2） 单调栈

	/**
	 * 2.单调栈
	 * 时间复杂度O(n)
	 * 空间复杂度O(n)
	 * @param height
	 * @return
	 */
	public int trap2(int[] height) {
		int res = 0;
		Deque<Integer> stack = new LinkedList<Integer>();
		int n = height.length;
		for(int i = 0;i < n;i++) {
			while(!stack.isEmpty() && height[i] > height[stack.peek()]) {
				int top = stack.pop();
				if(stack.isEmpty()) {
					break;
				}
				int left = stack.peek();
				int curWidth = i-left-1;
				int curHeight = Math.min(height[left], height[i]) - height[top];
				res += curWidth * curHeight;
						
			}
			stack.push(i);
		}
		return res;
	}

（3） 双指针

思路：注意到下标 i 处能接的雨水量由 leftMax[i] 和 rightMax[i] 中的最小值决定。由于 leftMax 是从左往右计算，数组 rightMax 是从右往左计算，因此可以使用双指针和两个变量代替两个数组。
维护两个指针 left 和 right，以及两个变量 leftMax 和 rightMax，初始时left=0, right=n−1, leftMax=0, rightMax=0。指针 left 只会向右移动，指针 right 只会向左移动，在移动指针的过程中维护两个变量 leftMax 和 rightMax 的值。

当两个指针没有相遇时，进行如下操作：

  • 使用 height[left] 和 height[right] 的值更新 leftMax 和 rightMax 的值；
  • 如果 height[left] < height[right]，则必有 leftMax < rightMax，下标 left 处能接的雨水量等于 leftMax−height[left]，将下标 left 处能接的雨水量加到能接的雨水总量，然后将 left 加 1（即向右移动一位）；
  • 如果 height[left] ≥ height[right]，则必有 leftMax ≥ rightMax，下标 right 处能接的雨水量等于 rightMax−height[right]，将下标 right 处能接的雨水量加到能接的雨水总量，然后将 right 减 1（即向左移动一位）。
  • 当两个指针相遇时，即可得到能接的雨水总量。
	/**
	 * 3.使用双指针
	 * 时间复杂度O(n) ，其中 n 是数组 height 的长度。两个指针的移动总次数不超过 n。
	 * 空间复杂度O(1) ，只需要使用常数的额外空间
	 * 维护两个指针 left 和 right，以及两个变量 leftMax 和 rightMax
	 * @param height
	 * @return
	 */
	public int trap3(int[] height) {
		int res = 0;
		int left = 0;
		int right = height.length-1;
		int leftMax = 0;
		int rightMax = 0;
		while(left < right) {
			leftMax = Math.max(leftMax, height[left]);
			rightMax = Math.max(rightMax, height[right]);
			if(height[left] < height[right]) {
				res += leftMax - height[left];
				++left;
			}else {
				res += rightMax - height[right];
				--right;
			}
		}
		return res;
	}

1.6 (lee-344) 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

（1） 递归

	/*
	 * 1.递归
	 * 基本操作：交换一次对称位置的字符
	 * 结束条件：交换的位置重叠或者超过i>=j
	 */
	public void reverseString(char[] s) {
		int len = s.length;
		int start = 0;
		int end = len-1;		
		reverse(start,end,s);	
		System.out.print(s);
	}	
	private void reverse(int start, int end, char[] s) {
		if(start >= end) {
			return;
		}
		reverse(start+1, end-1, s);
		swap(start,end,s);
	}
	private void swap(int start, int end, char[] s) {
		char temp = s[start];
		s[start] = s[end];
		s[end] = temp;		
	}

（2） 双指针

思路：对于长度为 N 的待被反转的字符数组，我们可以观察反转前后下标的变化，假设反转前字符数组为 s[0] s[1] s[2] … s[N - 1]，那么反转后字符数组为 s[N - 1] s[N - 2] … s[0]。比较反转前后下标变化很容易得出 s[i] 的字符与 s[N - 1 - i] 的字符发生了交换的规律，因此我们可以得出如下双指针的解法：

将 left 指向字符数组首元素，right 指向字符数组尾元素。
当 left < right：
    交换 s[left] 和 s[right]；
    left 指针右移一位，即 left = left + 1；
    right 指针左移一位，即 right = right - 1。
当 left >= right，反转结束，返回字符数组即可。

	/*	
	 * 2.这道题使用双指针更快
	 * 时间复杂度O(n)，，其中 N 为字符数组的长度。一共执行了 N/2 次的交换。
	 * 空间复杂度O(1)
	 */
	public void reverseString1(char[] s) {
		int len = s.length;
		int start = 0;
		int end = len-1;
		while(start <= end) {
			char c = s[start];
			s[start++] = s[end];
			s[end--] = c;
		}
		System.out.print(s);
    }

1.7 (lee-31) 下一个排列

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。必须原地修改，只允许使用额外常数空间。
以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

输入：nums = [1,2,3]
输出：[1,3,2]

	/* 
	 * 两遍扫描：双指针、交换、反转
	 * 时间复杂度：O(n)
	 * 空间复杂度:O(1)
	 */
	public void nextPermutation(int[] nums) {
		int i = nums.length - 2;
		while(i >= 0 && nums[i+1] <= nums[i]) { //从后向前查找第一个顺序对
			i--;
		}
		if(i >= 0) {
			int j = nums.length - 1;
			while(j >= 0 && nums[j] <= nums[i]) {
				j--;
			}
			swap(nums,i,j); //交换nums[i] nums[j]
		}
		reverse(nums,i+1); //使用双指针反转  降序区间[i+1,n)
    }

	private void reverse(int[] nums, int start) {
		int i = start;
		int j = nums.length-1;
		while(i < j) {
			swap(nums,i,j);
			i++;
			j--;
		}	
	}

	private void swap(int[] nums, int i, int j) {
		int temp = nums[i];
		nums[i] = nums[j];
		nums[j] = temp;		
	}

2 练习链接

Xixw
关注
专栏目录
双指针 Double Pointer
yake1965
10-07 740
88. 合并两个有序数组 125. 验证回文串 141. 环形链表 167. 两数之和 II - 输入有序数组 202. 快乐数 283. 移动零 27. 移除元素
数据结构9-双指针(尺取法)(double pointer)
LiuKairui的博客
03-02 846
双指针有好几种，但是最常用的是尺取法，所以有的时候就说尺取法 双指针，指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢指针）或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。 分类有奇奇怪怪的几种，我写了三种 1.对撞指针(除了二分没啥用) 最经典的应用是二分 最最朴素的对撞指针就是 function fn (list) { var left = ...
DoublePointer (**)
07-16 182
双重指针 1 #include<stdio.h> 2 3 int main(viod) 4 { 5 int a = 1; 6 int b = 2; 7 int * p = &a; 8 int * p1 = p; 9 int * p2 = &b; 10 11 pr...
2D Array and double pointer
a130737的专栏
06-25 2245
首先， 在理解这两个概念之前， 我们看这两个danci
双指针技术（two-pointer technique）
“点点”专栏
12-24 696
要想用好双指针技术还是挺难的，尤其是快慢指针，所以单独开一篇文章 一、数组中使用双指针 （1）一个升序数字型的一维数组，给定一个目标值，找出数组中两个位置，这两个位置元素的和等于目标值。 Two Sum II - Input array is sorted 思路：采用从两端都中间移动的双指针技术。两指针元素的和大于目标值，右指针向前移，如果两指针元素的和小于目标值，左指针后移，直到相等。 ...
双指针 double pointer
jiayue的博客
04-29 849
目录27 移除元素26 删除排序数组中的重复项283 移动零844 比较含退格的字符串977 有序数组的平方 fastp用于遍历数组中每个元素，slowp用于指向数组中待赋值的位置，并等待fastp寻找到符合要求的给其赋值 这种题目一般都要求原地修改，最后返回的应该是slowp指向的位置前面所有部分，因为这一部分才是符合要求的 27 移除元素 easy 题目描述 给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空
双指针（two pointers）
qq_42001076的博客
02-02 677
双指针（two pointers） 背景： 给出一个递增正整数序列A和正整数M,求序列中不同位置的数a和b，使它们的和为M的所有组合。一种解决方案是遍历两次序列数组，分别是x和y，然后根据它们和进行判断，但这种方法复杂度为O（n*2）。 方法： 因为是递增序列，我们设两个指针或者点分别指向数组的头（0）和尾（n-1),分别记下标为i,j： 1.A[i]+A[j]>M => A[k]+A[j]>M(k>=i) => 若区间[i,j]存在a+b=M，则大的那个数下标绝不是j，则只能
鼠标指针双「Mouse Pointer Double」-crx插件
03-15
此扩展是作为快速练习而创建的，灵感来自Frank Katzenberger的帖子：https://plus.google.com/+FrankKatzenberger/posts/abUA9UJZB4x您可以在以下位置找到源代码：https://github.com/fczbkk/鼠标指针双 支持语言:...
指针(Pointer)
Hacket_Xu的博客
10-15 960
指针是一种数据类型，指针变量的值是另一个变量在内存中的地址。每一个变量都有一个名字，且在内存中占据一个内存位置（地址），可以通过。计算机的内存中每个存储单元都是有序的，都是按字节编码，字节是最小的存储单位。在定义指针的时候如果不一开始就赋值的话，建议赋空，避免出错。这样的赋值后，p1和p2指向同样的地址，对p2的任何更改都会影响p1的值。这其中，->用于指向结构体的指针，表示结构体内的元素。操作内存上的值，也可以通过地址间接操作内存上的值。而64位编译器的内存中，内存空间的地址最多到。
二级指针（double pointer）或称为指针的指针
最新发布
qq_33089547的博客
04-06 307
在C++中，二级指针（double pointer）或称为指针的指针，是一个指向指针的指针。这意味着二级指针存储的是一个指针的地址，而这个指针又指向另一个地址。
Arrays-DoublePointers:数组以及数组中使用双指针技巧
04-14
Arrays-DoublePointers 在java中，提供了静态数组和动态数组两种。静态数组需要提前初始化好，并且初始化后长度不能被改变了，比如int[] temp = new int[7];也可以使用动态数组List temp = new ArrayList<>(); 对角线遍历 给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素。 输入: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 输出: [1,2,4,7,5,3,6,8,9] 解决该题，只需要仔细观察出遍历的规律即可。一个指针有两种遍历方向，分别是斜向上和斜向下，在斜向上方向的遍历，有三种不同的更新横纵坐标的情况；在斜向下方向的遍历上，也有三种不同的更新横纵坐标的情况，然后用代码实现即可。 package practice; im
double pointer pointers array
weixin_33693070的博客
09-28 152
https://stackoverflow.com/questions/33746434/double-pointer-vs-array-of-pointersarray-vs-array
深入理解双指针
热门推荐
Legend(谭海燕)的专栏
02-09 2万+
 深入理解双指针          对于C语言的参数传递都是值传递，当传传递一个指针给函数的时，其实质上还是值传递，除非使用双指针。          在讲双指针之前，还是先讲讲关于C语言函数调用的本质。函 数调用操作包括从一块代码到另一块代码之间的双向数据传递和执行控制转移。数据传递通过函数参数和返回值来进行，包括局部变量的空间分配与回收，都是通过 栈来实现的。绝
双指针 Two Pointers
HelloWorld
01-19 698
双指针 Two Pointers双指针题型 双指针题型
双指针（Two Pointers）用法精讲及解题案例
baidu_33164415的博客
12-27 303
双指针（Two Pointers）用法精讲及解题案例
【剑指Offer】双指针(2)
Chris_Eddy的博客
09-21 168
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。 示例： 输入：nums = [1,2,3,4] 输出：[1,3,2,4] 注：[3,1,2,4] 也是正确的答案之一。 提示： 0 <= nums.length <= 50000 1 <= nums[i] <= 10000 class Solution { public: vector<i
Python算法——双指针
qq_61707205的博客
05-15 5547
双指针（Two Pointers）：指的是在遍历元素的过程中，不是使用单个指针进行访问，而是使用两个指针进行访问，从而达到相应的目的。 双指针分为「对撞指针」、「快慢指针」、「分离双指针」。     对撞指针：两个指针方向相反。适合解决查找有序数组中满足某些约束条件的一组元素问题、字符串反转问题。     快慢指针：两个指针方向相同。适合解决数组中的移动、删除元素问题，或者链表中的判断是否有环、长度问题。   &nb
two-pointer 双指针法—初步介绍
A_Bright_CH的博客
03-22 1190
例题1：给出n个数，找出和最接近k的两个数。思路 ：对数组进行排序，一个指针指向1（最小），另一个指向n（最大）。如果两指针之和大于k，则右指针左移1；如果两指针之和小于k，则左指针右移1。其中左移意为使值变大，右移意为使值变小，两两交换移动，就能最大可能的接近k。例题2：给出n个数，找出和最接近k的三个数。思路 ：枚举1个数，其余与例题1一致。注意对于nums[st]，nums[ed]和nums...
双数据指针，指的是什么
07-12
双数据指针（Double Pointer）是指在编程中使用两级间接寻址的指针。 在C语言中，指针是一个存储变量地址的变量。通过指针，我们可以访问和修改存储在特定内存地址上的数据。而双数据指针实际上是指向指针的指针，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值