俩数之和

给定一个整数数组，一个目标值，输出相加等于目标值的数的下标。

最简单：暴力法：双层循环
俩层循环O(n2)
思路二：
排序后双指针
细节处理，
排序后下表改变，所以需要构造node接点存下标

class Solution {
public:    
typedef struct node    {        
int val;        
int idx;        
bool operator <(const node &s) const                                    //重载<运算符，目的是调用sort函数以node.val的升序进行排列        
{            
return val<s.val;        
}     
}node;     
vector<int> twoSum(vector<int>& nums, int target) {
 vector<node> nodenums;        
for(int i=0;i<nums.size();i++)//构造nodenums数组并按val的值升序排列        {            
node no;            
no.val=nums[i];            
no.idx=i;            
nodenums.push_back(no);        
}        
sort(nodenums.begin(),nodenums.end());                
vector<int> res;  //res返回结果        
int i=0,j=nums.size()-1;    
while(i<j){         
int sum =nodenums[i].val + nodenums[j].val;        
if(sum < target) i++;        
if(sum > target) j--;        
if(sum == target){           
            res.push_back(nodenums[i].idx);           res.push_back(nodenums[j].idx);            
            break;        
          }    
        }        
        return res;    
     }
 };

思路三 map处理

map，键值对

map的另外一种unordered_map：

无需有序，用unordered_map
运行时间多于map

class Solution {
public:    
vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;
                
        for(int i = 0; i < nums.size(); i++) {           
	        auto iter = map.find(target - nums[i]);            
	        if(iter != map.end()) {//找到                
	             return {iter->second, i};
	       //  iter->second存的是下标，i则为另一个与其相加为目标的下标          
	            }            
	        map.insert(pair<int, int>(nums[i], i));       
     }        
    return {};    
   }
 };