1. Two Sum

问题描述：

input : 一个数组nums；一个target

output：找到数组中两个元素之和等于target，并返回这两个元素在数组中的index

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

解法：

1.暴力方法

双重循环遍历整个数组nums，直到找到两个数的和=target

时间复杂度O()

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        /*暴力方法*/
        vector<int> res;
        for(int i = 0; i < nums.size(); i++)
        {
            int v = target - nums[i];
            for(int j = i + 1; j < nums.size(); j++)
            {
                if(nums[j] == v)
                {
                    res.push_back(i);
                    res.push_back(j);
                    return res;
                }
            }
        }
        return res;        
    }
}；
        

2.map

map可以实现通过value找到index：

        map中的key：nums的元素值；value：元素在数组nums中的index

思想：在循环中遍历整个数组nums，对于当前遍历到的元素nums[i]，查找在map中是否存在值 = target - nums[i]

     （1） 如果存在：说明成功找到了这两个数，return这两个元素的index（注意这两个元素inidex，小的在前，大的在后，在本代码中map中取出的元素index一定 < 当前元素的index i）

      （2）如果不存在：就将当前遍历到的数组元素插入到map中，key是当前元素的值，value是当前元素的index

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        /*
        map
        //map可以实现通过value找到其index
        */
        vector<int> res;
        map<int,int> map;
        for(int i = 0; i < nums.size(); i++)
        {
            int v= target - nums[i];           
            if(map.find(v) != map.end())
            {
                res.push_back(map[v]);
                res.push_back(i);
                return res;
            }
            else
            {
                map[nums[i]] = i;
            }            
         }
        return res;
    }
}；

3.双向扫描

思路：

（1）备份原数组nums为back_nums（因为后面要对数组进行排序，这里备份一份，记录下元素在原始数组中的index）

（2）对数组进行排序（调用sort函数自动排序）

（3）从前往后(min)，从后往前(max)对排序后的数组进行双向扫描，

         如果两个数的和<target: min++;

         如果两个数的和>target: max--;

         注意外层循环结束的条件是：两数之和！=target

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        /*
        排序&最大数最小数
        */  
        vector<int> res;
        vector<int> back_nums(nums);
        
        sort(nums.begin(), nums.end());
        
        int min = 0;
        int max = nums.size() - 1;
        
        //##########外层循环注意判断条件！！！
        while(nums[min] + nums[max] != target)
        {
            while(nums[min] + nums[max] < target)
            {
                min++;
            }
            while(nums[min] + nums[max] > target)
            {
                max--;
            }            
        }
        //找到两个数在原数组的index
        for(int i = 0; i < back_nums.size(); i++)
        {
            if(nums[min] == back_nums[i] || nums[max] == back_nums[i])
            {
                res.push_back(i);
            }
        }
        return res;     
    }
};