双指针问题(python版)

双指针问题

双指针在日常生活中很常见，leetcode中也有许多的题目与之相关。接下来是几个双指针的案例。

需要注意的一个点：如果想知道一道题目是否能使用双指针，你就需要去判断，该指针所指向的值，两个是否能进行合理的判断（三数之和中，两个指针所指向的值经过计算与0的比对结果控制指针的走向，而雨水问题中，两个指针所指向的柱子高度较小值于指针值的差的乘积于当前面积的比对结果控制指针走向）

下面就是双指针的一些例题：

一、三数之和问题

1. 题目

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

说起三数之和，我们首先需要回忆以下两数之和，如果两数之和你直接使用暴力的解法，很可能会出现超时问题，要使时间复杂度将下来，你就需要使用一个哈希表，表中存放该值与其下表的映射关系。然后后续进行判断，如果不存在，则继续加入，如果存在，则返回两个下标值。说完说两数之和，我们就可以开始我们的三树之和了。

2. 思路

暴力破解肯定是从脑子里迸发出的第一个求解方式，但是肯定会造成超时问题，因为时间复杂度已经达到了$O(n^3)$，而要使时间复杂度降下来，我们就可以使用双指针。

首先从第一个元素开始到倒数第三个元素（因为始终需要有两个值），然后第一个数为low指针，最后一个为high指针，然后三个数进行相加，如果小于规定值，则low+1，如果大于则high-1。遇到了就把值加上去，如果没有就进行下一个循环。

3. 代码实现

下面就是比较经典的双指针求解三数之和的方法：

def sum3(nums):
	n = len(nums)  # 获取列表的长度
	res = []  # 声明一个结果集
	if n < 3:  # 如果整个列表的长度小于三，则直接return
		return res
	nums.sort()  # 对数组进行排序
	# 排序后，进行第一次剪枝
	if sum(nums[:3]) > 0 or sum(nums[-3:]) < 0:  # 如果当前最小的三个值加起来都大于0或者最大的值加起来都小于0，则说明不可能存在
		return res

	for i in range(n-2):
		# 进行第二轮剪枝
		if nums[i] > 0:  # 如果该数大于0，则不可能存在
			return res
		if nums[i] + sum(nums[-2:]) < 0 or sum(nums[i:i+3]) > 0:  # 如果当前值加上最大的两个数还是小于0或者当前的最小的三个数都已经大于0，则说明不存在
			continue
		if i > 0 and nums[i] == nums[i - 1]:
			continue

		low = i + 1
		high = n - 1
		while low < high:
			count = nums[i] + nums[low] + nums[high]
			if count < 0:  # 如果三个数之和小于0，则low指针往右移
				low += 1
			elif count > 0:  # 如果三个数之和大于0，则high指针往左移
				high -= 1
			else:
				midle = [nums[i], nums[low], nums[high]]
				if midle not in res:  # 判断当前值是都已经出现在结果集中
					res.append(midle)
				low += 1
				high -= 1
	return res

二、四数之和

1. 题目

给定一个包含n 个整数的数组nums和一个目标值target，判断nums中是否存在四个元素 a，b，c和 d，使得a + b + c + d的值与target相等？找出所有满足条件且不重复的四元组。

2. 思路

四数之和的思路与三数之和的思路差不多，就是在三数之和之前再加一层循环即可

3. 代码实现

def sum4(nums, target):
	n = len(nums)
	res = []
	if n < 4:
		return res
	if n == 4 and sum(nums) == target:
		return [nums]
	nums.sort()

	# 剪枝
	if sum(nums[:4]) > target or sum(nums[-4:]) < target:
		return res

	for i in range(n-3):  # 第一层循环
		for j in range(i + 1, n - 2):  # 第二层循环
			low = j + 1
			high = n - 1
			while low < high:
				count = nums[i] + nums[j] + nums[low] + nums[high]
				if count < target:
					low += 1
				elif count > target:
					high -= 1
				else:
					mid = [nums[i], nums[j], nums[low], nums[high]]
					if mid not in res:
						res.append(mid)
					low += 1
					high -= 1
	return res

三、盛最多水的容器

1. 题目

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

2. 思路

要完成这个代码，首先我们还是使用双指针。首先设置两个指针，一个从左开始，一个从右开始。先判断那个数小，体积就等于当前最小的数*（右指针-左指针）。然后与原来的进行比较。最后如果小的是左指针，则左指针往右移，如果小的是右指针，则右指针往左移，直到左指针不再小于右指针为止。

3. 代码实现

def maxarea(height):
	area = 0
	left = 0
	right = len(height) - 1

	while (left < right):
		if height[left] < height[right]:
			area = max(area, height[left]*(right - left))
			left += 1
		else:
			area = max(area, height[right]*(right - left))
			right -= 1
	return area

四、除自身以外数组的乘积

1. 题目

给你一个长度为n的整数数组nums，其中n > 1，返回输出数组output，其中 output[i]等于nums中除nums[i]之外其余各元素的乘积。
注：不能使用除法

2. 思路

第一种，双指针，首先获取当前的值i，前面的列表从0到i-1，后面的列表从i+1 到N，这样只要循环迭代每个值进行乘积即可得到对应的答案。但是发现，这样虽然也是双指针，但是时间复杂度是O（n2）的，因此有没有更好的方法呢

第二种：官方解答中，我们可以使用获取值整个列表的前缀和后缀，然后在将他们相乘即可达到答案。
下面的算法就直接使用第二种来求解

3. 代码实现

def productExceptSelf(nums):
	n = len(nums)  # 获取整个列表的长度
	answer = [0]*n  # 声明一个列表，长度为n所有值为0

	# 应为第一个数没有前缀，所以我们需要默认它为1，从第二个开始，只需要使用之前记录的answer前一个与nums前一个相乘就是当前位置的答案
	answer[0] = 1
	for i in range(1, n):
		answer[i] = nums[i - 1] * answer[i - 1]

	# 应为最右边的值没有后缀，因此我们需要声明R为1，接下来从后往前，通过与answer相乘来得到最终的答案。
	R = 1
	for i in range(n - 1, -1, -1):
		# 对于当前值，是answer的相同位置的值与R进行相乘
		answer[i] *= R
		# R就是当前的R值与nums值进行相乘
		R *= nums[i]

	return answer

五、接雨水

1. 题目

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

2. 思路

思路：暴力解法，从第一个开始到最后一个，获取该值左边的最高值（l）和右边的最高值（r），判断l和r的大小，较小的与当前值相减就是该柱子的蓄水量

思路2：双指针法。双指针与暴力法类似，只是暴力从头开始，而双指针是从两端往中间走。这两个的核心都是，比较当前值左边的最大值和右边最大值，将这两个值的较小值与自己相减就是该柱子的积水量

3. 代码实现

第一种：暴力解法

def trap(height):
	if len(height) <= 2:
		return 0
	res = 0
	for i in range(1, len(height) - 1):
		# 进行查找时，一定需要把自己加进去，
		left_max = max(height[:i + 1])
		right_max = max(height[i:])
		res += min(left_max, right_max) - height[i]
	return res

第二种：双指针

def trap2(height):
	# 如果height的长度小于等于2，则直接返回，因为两个柱子无论怎么样都不可能盛水
	if len(height) <= 2:
		return 0
	res = 0  # 设置结果集
	left, right = 0, len(height) - 1  # 设置左指针0和右指针len-1
	left_max, right_max = height[0], height[-1]  # 设置左边最大值和右边最大值
	while left <= right:
		left_max = max(left_max, height[left])  # 判断当前柱子左边（包括自己）的最大值
		right_max = max(right_max, height[right])  # 判断当前柱子右边的最大值（包括自己）
		if left_max < right_max:  # 如果左边最大值小于右边，则左边最大值减去自己高度就是这根柱子的蓄水量，左边主子往右移动
			res += left_max - height[left]
			left += 1
		else:  # 如果左边最大值大于等于右边，则右边最大值减去自己的高度就是这跟柱子的蓄水量，右边柱子往左移动
			res += right_max - height[right]
			right -= 1
	return res

经过上面5题大约也能理解双指针的一些思路了，接下里就是多刷题，好好的复习和反思。