1.两数之和

原题

        给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回他们的数组下标。

        这道题的本质是搜索，给定整数数组有序的话，可以采用二分法来搜索数组，但是如何避免重复的问题是我们应该解决的。例如nums = [2， 7， 11， 15] target = 9当遍历到2时会和7组成一对，如果不对原数组进行操作的话，当遍历到7时又会生成重复的数组。所以当找到和这个数匹配的数字时，我们可以把这个数变成空值。二分的开始可以从当前遍历到的数字开始搜索，因为遍历时前面的所有数字都已经判断过了。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> results;
        for(int i=0; i<nums.size() - 1; i++){
            if(nums[i] == -100){
                continue;
            }
            int middle;
            int head = i + 1;
            int tail = nums.size() - 1;
            while(head<=tail){
                middle = head + ((tail - head) / 2);
                if(target - nums[i]>nums[middle]){
                    head = middle + 1;
                }
                else if(target - nums[i]<nums[middle]){
                    tail = middle - 1;
                }
                else{
                    results.push_back(middle);
                    results.push_back(i);
                    nums[middle] = -100;
                }
            }
        }
        return results;
    }
    
};

当我吧代买写完，提交的时候样例过不去，这时我才发现所给数组并不是有序的，所以先排序，但是我返现要求的结果需要返回索引..........GGGGG。那没有什么好说的了，直接采用暴力枚举法。

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

需要的时间比较多，所以想到哈希表来解决搜索的时间问题，采取用空间换区时间的算法。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> h;
        for(int i=0; i<nums.size(); i++){
            auto it = h.find(target - nums[i]);
            if(it != h.end()){
                return{it->second, i};
            }
            h[nums[i]] = i;
        }
        return {};
    }
};