LeetCode Two Sum

两个整数求和等于一个特定的值，返回这两个整数的下标，第一个数的下标要小于第二个数。

解题思路：

1.暴力搜索(O(n^2))

2.先对数据进行排序，然后查找(O(nlogn))

3.利用散列表(O(n))

对于第2种思路，可以建立一个一个struct，包含整数的值和下标，对值排序，并不影响返回的下标值。

代码如下：

    struct node{
        int val;
        int idx;
        node(){}
        node(int a,int b):val(a),idx(b){}
    };
    bool compare(const node& a,const node& b){
        return a.val<b.val;
    }
class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> ret(2,0);
        int size=numbers.size();
        vector<node> adds(size);
        for(int i=0;i<size;i++){
            adds[i]=node(numbers[i],i+1);
        }
        sort(adds.begin(),adds.end(),compare);
        int left=0;
        int right=size-1;
        while(left<right){
            int sum=adds[left].val+adds[right].val;
            if(sum==target){
                ret[0]=min(adds[left].idx,adds[right].idx);
                ret[1]=max(adds[left].idx,adds[right].idx);
                break;
            }
            else if(sum<target)
            left++;
            else 
            right--;
        }
            return ret;
    }
};

对于第3种思路，散列表可以提高查找的速度

代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> ret(2,0);
        int size=numbers.size();
        map<int,int> mp;
        for(int i=0;i<size;i++){
        mp[numbers[i]]=i+1;
        }
        map<int,int>::iterator it=mp.end();
        for(int i=0;i<size;i++){
            it=mp.find(target-numbers[i]);
            if(it!=mp.end() && it->second!=i+1){
                ret[0]=min(i+1,it->second);
                ret[1]=max(i+1,it->second);
                break;
            }
      }
            return ret;
    }
};