1. 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

我的解答：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int low=0,high=nums.size()-1,sum=0;
        vector<int> result;
        while(low<high)
        {
            sum=nums[low]+nums[high];
            if(sum==target)
            {
                result.push_back(low);
                result.push_back(high);
                break;
            }
            else if(sum<target)
                low++;
            else
                high--;
        }
        return result;
    }
};

问题：1.没有读题仔细（题目中没有描述数组中的数据是有序的）。2.对vector的操作不熟悉。3.对map不熟悉。

vector常用操作
定义：vector<int> a； vector<int> b(2,-1);//建立一个数组，大小为2，初始化为-1
长度：a. size()；
插入元素： a.push_back(2)//在末尾插入元素2
a.insert(0,2)//在0下标处插入2

map常用操作
定义：map<int,int> a;//建立<key，value>都为int 的哈希表
插入元素：a.insert(map<int,string>::value_type(000,“stu0”))
a.insert(map<int,int>::value_type(nums[i],i));
查找元素：a.cout()//返回目标key是否存在，只会是0和1.

改进1.0：暴力遍历

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i,j;
        for(i=0;i<nums.size();i++)
        {
            for(j=i+1;j<nums.size();j++)
            {
                if(nums[i]+nums[j]==target)
                    return {i,j};
            }
        }
        return {i,j};
    }
};

分析：时间复杂度O(n²) 空间复杂度O(1)，尽量使时间复杂度降低。

改进2.0：使用哈希表（方便用查找功能）

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //定义一个map
        map<int,int> a;
        int i;
        //把nums元素移到a中
        for(i=0;i<nums.size();i++)
            a.insert(map<int,int>::value_type(nums[i],i));
        //查找符合的数据
        for(i=0;i<nums.size();i++)
        {
            //若存在两数之和为target 且不是一个数加了两次
            if(a.count(target-nums[i])>0&&a[target-nums[i]]!=i)
                return {i,a[target-nums[i]]};
        }
        return {i,a[target-nums[i]]};
    }
};

分析：时间复杂度O(n) 空间复杂度O(n)
数据结构：使用了STL关联容器map，map中count函数可以查找关键字出现次数（关键字不允许重复）。

改进3.0：使用哈希表，在数组插入哈希表时就验证目标值是否存在。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> a;
        vector<int> b(2，-1);
        for(int i=0;i<nums.size();i++)
        {
            a.insert(map<int,int>::value_type(nums[i],i));
            if(a.count(target-nums[i])>0&&a[target-nums[i]]!=i)
            {
                b.push_back(i);
                b.push_back(a[target-nums[i]]);
                break;
            }
        }
        return b;
    }
};

分析：平均时间和空间使用的更小了。

总结：熟悉STL关联容器。