背景
面试深圳某互联网证券公司，算法题是给一个固定时间区间的股票价格，找出最佳买卖时机，使得收益最大，其中一天只能买卖操作一次。这里最佳方案是使用双指针方法。在学习字符串和数组的一些算法题时，发现常用的双指针方法可以解决很多问题，并且可以有效的降低时间复杂度。最早接触双指针方法是链表的快慢指针，用来判断一个单项链表是否有环。
这篇文章将接触到的经典双指针法用在一些字符串和数组的算法做一个简单的总结。
介绍
双指针有两种方案：
- 前后指针，一个是数组的起始位置，一个是数组的结束位置
- 快慢指针，一个快指针进行遍历，一个慢指针在某些特殊条件下移动
前后指针迭代
前后指针的一般步骤如下：
- 指定一个往右遍历的指针
leftIndex和一个向左遍历的指针rightIndex - 判断
leftIndex和rightIndex对应的元素关系（根据题目） - 根据条件来更新
leftIndex和rightIndex - 结束条件是
leftIndex == rightIndex
实例1：升序数组两个数的和等于目标数
给定一个已按照升序排列的有序数组，找到两个数使得他们相加之后等于目标数。
函数应该返回这两个下标值index1和index2，其中index1必须小于index2
示例：
输入：numbers = [2, 5, 7, 11, 15], target = 9
输出：[1, 2]
注意：返回的下标值index1和index2不是从零开始
分析
题目给出数组是升序数组，所以我们可以使用前面介绍的前后指针遍历方法。
当
leftIndex的元素值和rightIndex的元素和相等与目标值时，代表找到了两个索引。如果小于目标值，则
leftIndex的指针右移。如果大于目标值，则
rightIndex的指针左移。如果
leftIndex等于rightIndex，则没有找到。
如下图所示：
代码
// swift实现
func twoSum(_ numbers: [Int], _ target: Int) -> [Int] {
// 如果数组是空，则直接返回[-1]
if numbers.isEmpty {
return [-1]
}
var left = numbers.startIndex
var right = numbers.endIndex - 1
while left < right {
let sum = numbers[left] + numbers[right]
if sum == target {
return [left + 1, right + 1] // 找到直接返回
} else if sum > target {
right -= 1
} else {
left += 1
}
}
return [-1]
}
复杂度
时间复杂度：O(N)
空间复杂度：O(1)
快慢指针遍历
另外一种常见的方法就是使用快慢指针遍历，一般步骤如下：
- 定义一个慢指针
slowIndex和快指针quickIndex都指向数组的第一个位置 -
quickIndex每次移动一步，而slowIndex在满足某个特定条件的时候移动一步 - 当前
quickIndex结束之后，slownIndex指向的就是新数组的最后一位
实例1
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
示例：
输入：s = 7, nums = [2, 3, 1, 2, 4, 3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
分析
定义两个指针slowIndex和quickIndex，快指针每移动一步，则计算慢指针到快指针之和sum，并记下子数组的长度minLength。
如果sum的值大于或者等于目标值s，slowIndex移动一步，继续计算sum的和，更新minLength。
如果sum小于目标值s，则quickIndex继续移动
如下图所示：
代码
// swift实现
func minSubArrayLen(_ s: Int, _ nums: [Int]) -> Int {
// 数组如果是空直接返回为0
if nums.isEmpty {
return 0
}
var slow = nums.startIndex
var minLength = Int.max
var sum = 0
for i in 0..<nums.count {
sum = sum + nums[i]
while sum >= s {
minLength = min(minLength, i - slow + 1) // 找到最小的长度
sum = sum - nums[slow]
slow += 1
}
}
return (minLength == Int.max ? 0 : minLength)
}
复杂度
时间复杂度：O(N)
空间复杂度：O(1)
练习
习题1：翻转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII码表中的可打印字符。
代码
// swift实现
func reverseString(_ s: inout [Character]) {
var leftIndex = s.startIndex
var rightIndex = s.endIndex - 1
while leftIndex < rightIndex {
let tempCharacter = s[leftIndex]
s[leftIndex] = s[rightIndex]
s[rightIndex] = tempCharacter
leftIndex += 1
rightIndex -= 1
}
}
习题2：最大连续1的个数
给定一个二进制数组， 计算其中最大连续1的个数。
示例 1:
输入: [1,1,0,1,1,1]
输出: 3
解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3.
注意：
- 输入的数组只包含
0和1。 - 输入数组的长度是正整数，且不超过 10,000。
代码
func findMaxConsecutiveOnes(_ nums: [Int]) -> Int {
var ret = 0
var count = 0
for num in nums {
if num != 1 {
ret = max(count, ret)
count = 0
} else {
count += 1
}
}
return max(count, ret)
}
买卖股票的最佳时机
回到开头，发现原来这个题目也是刷题网站(leetcode)上的。
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
注意：你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2:
输入: [7,6,4,3,1]]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
代码
func maxProfit(_ prices: [Int]) -> Int {
var slowIndex = prices.startIndex
var maxDiff = Int.min
for i in 0..<prices.count { // 快指针一个一个遍历
let diff = prices[i] - prices[slowIndex] // 收益
if diff > 0 {
maxDiff = max(maxDiff, diff) // 最大收益
} else {
slowIndex = i // 移动慢指针到i
}
}
return max(maxDiff, 0)
}
总结
双指针方法，可以解决大部分数组和字符串的问题。深刻了解原理，对解这方面的题目还是一个比较重要的思考方向。
