leetcode 1: twosum

题目描述：给出一个int数组和一个int目标值，在数组中找两数之和等于target。假设肯定能找且每个数只能用一次。返回两数在数组的下标。

方法一：暴力求解

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        for(int i=0;i<nums.size();i++){
            for(int j=i+1;j<nums.size();j++){//每个数只能用一次
                if(nums[i]+nums[j]==target)
                    return vector<int>{i,j};//多借鉴这种返回vector的方法 
            }
        }
        return vector<int>{-1,-1}; 
    }
};

不足：时间复杂度是o（）

优点：思路清晰、简单

方法二：借助 unordered_map

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
       if(nums.size()<=1) return vector<int>{-1,-1};
        unordered_map<int,int> hash;
        for(int i=0;i<nums.size();i++){
            hash[nums[i]]=i;
        }
        for(int j=0;j<nums.size();j++){
            if(hash.find(target-nums[j])!=hash.end() && hash[target-nums[j]]!=j){//每个元素只能用一次
                return vector<int>{j,hash[target-nums[j]]};
            } 
        }
        return vector<int>{-1,-1};
    }
};

改进编码版：

少了一层循环，不必先全部插入hash,而是一边判断，一边插入。因为两数和具有交换等效性，通过前面的数找不到，后面找也是等价的，并不会漏掉！

很值得借鉴！！！！！！！！！！！！！

class Solution {
public:
      vector<int> twoSum(vector<int>& nums, int target) {
       if(nums.size()<=1) return vector<int>{-1,-1};
          unordered_map<int, int> hash;
    
        for (int i = 0;i<nums.size(); ++i) {
             auto it = hash.find(target - nums[i]);
             if (it != hash.end()) 
                return vector<int> {i, it->second};   //此处不担心使用重复元素，因为判断时元素还未插入
            hash[nums[i]] = i;
        }
       return vector<int>{-1,-1};   
   }
};

不足：前提要求数组中没有相同元素

优点：时间复杂度o(n)

拓展：先排序，两个指针分别从两端向中间收拢。但是只能判断能否the sum  of 2 nums equals target,因为排序会打乱下标。