双指针应用：反转字符串、数组拆分I、两数之和II-输入有序数组；

题目：反转字符串

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

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

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

 

示例 1：

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：

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

分析:直接用最简单的双指针进行一次遍历就ok了

class Solution {
public:
    void reverseString(vector<char>& s) {
        int n = s.size();
        if(n == 0)
            return;
        
        int front = 0, back = n - 1;
        
        while(front < back)
        {
            char temp = s[front];
            s[front] = s[back];
            s[back] = temp;
            front++; 
            back--;
        }
        
        return ;
        
    }
};

---

题目：数组拆分

给定长度为 2n 的数组, 你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，
使得从1 到 n 的 min(ai, bi) 总和最大。

示例 1:

输入: [1,4,3,2]

输出: 4
解释: n 等于 2, 最大总和为 4 = min(1, 2) + min(3, 4).
提示:

n 是正整数,范围在 [1, 10000].
数组中的元素范围在 [-10000, 10000].

分析：
我们永远五大得到最大的元素，所以希望借助最大元素和第二大元素的组合得到第二大元素，这样对于这个组合来说，损失是最小的；
那么对于整个数组来说，如何损失最小？越相近的元素组合，损失越小
所以考虑直接排序，因为是2n个元素，所以一定能够组合；从小到大遍历，隔一个元素就是能够得到的元素；

代码：

class Solution {
public:
    int arrayPairSum(vector<int>& nums) {
        int n = nums.size();
        int max_sum = 0;
        sort(nums.begin(), nums.end());
        
        for(int i = 0; i < n; i+=2)
        {
            max_sum += nums[i];
        }
        return max_sum;
            
    }
};

---

题目：两数之和，输入有序数组

两数之和 II - 输入有序数组
给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:

返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:

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

分析：
最简单的就是暴力循环，外层是当前元素，内层循环是剩下的元素；—>会超时pass

思考如何解决：因为是一个已经排序的数组，那么两数之和一旦大于target，证明左边的数太大，或者右边的数太大
如果我们将两个指针分别指向这个数组的开始和结尾； 如果两数之和 > target，证明右边的数太大了，只需要将右边的指针左移；同理，太小则左边向右移；

注意： 这样思考有一个小问题：如果 > target 需要左指针右移，有没有可能这时需要，右指针右移呢？

我们从最初的起点思考，如果 >target，右指针左移，这时是唯一方案能够向target逼近，此时的左右指针之间的元素必然是解所在的区间；同理可证 < target时；（类似于夹逼定理）

代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int m = numbers.size();
        int front = 0, back = m -1;
        vector<int> ret(2,0);
        while(front < back)
        {
            if(numbers[front] + numbers[back] > target)
                back--;
            else if(numbers[front] + numbers[back] < target)
                front++;
            else{
                ret[0] = front+1;
                ret[1] = back+1;
                break;
            }    
        }
        return ret;
    }
};