leetcode:two sum

Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

 

Show Tags

Show Similar Problems

 

解法一：

      采用简单Brute Force算法，从序列一端开始遍历至另一端，寻找满足要求的解。提交之后发现提示“Time Limit Exceeded”，立刻明白题目不会这么简单，毕竟是各大IT企业的笔试题，这道题目如果简单的两重循环遍历时间复杂度是O(N^2)，如果array元素个数很多，时间因素将是瓶颈。

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        int i, j, sum;
        vector<int> results;
        for(i=0; (i<numbers.size()-1); i++){
            //if(numbers[i]>target) continue; //这样判断不行，因为可能有负数+正数=target的情况
            for(j=i+1; j<numbers.size(); j++){
                //if(numbers[j]>target) continue;
                sum=numbers[i]+numbers[j];
                if(sum==target){
                    //cout<<"index1="<<(i+1)<<", index2="<<(j+1)<<endl;
                    results.push_back(i+1);
                    results.push_back(j+1);
                }
            }
        }
        return results;
    }
};

解法二：

　　　查过一些资料，许多人是用哈希表实现快速查找的，然后就去恶补哈希原理、C++容器等blabla，第二种解法是参照别人的，其实理解起来不难，下面的方法很好的利用了C++容器map的特性，map是基于红黑树（Red Black Tree）的数据结构，查找时间复杂度O(logN)，虽然不及Hash Table的O(1)，但C++容器并没有Harsh，所以用好C++函数就能解决大部分问题，但自己能理解最好了。

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        int i, sum;
        vector<int> results;
        map<int, int> hmap;
        for(i=0; i<numbers.size(); i++){
            if(!hmap.count(numbers[i])){
                hmap.insert(pair<int, int>(numbers[i], i));
            }
            if(hmap.count(target-numbers[i])){
                int n=hmap[target-numbers[i]];
                if(n<i){
                    results.push_back(n+1);
                    results.push_back(i+1);
                    //cout<<n+1<<", "<<i+1<<endl;
                    return results;
                }

            }
        }
        return results;
    }
};

解法三：

     在discuss板块，看到有童鞋share自己15ms的代码，分析其代码主要是用排序sort()方法先让array有序，再遍历找到index1、index2对应的Value（这个遍历比较巧妙，赞！），最后从原来array向量中找出对应的Key值，即index1、index2。时间复杂度主要是排序算法sort()，O(NlogN)。

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> v = numbers;
        sort(v.begin(), v.end());
        int left = 0;
        int right = (int) v.size() - 1;
        int middle;
        while (left < right) {
            int middle = v[left] + v[right];
            if (middle == target) break;
            if (middle < target) 
                ++left; 
            else 
                --right;
        }

        int result_index1;
        int result_index2;
        for (int i=0;i<v.size();++i) {
            if (numbers[i] == v[left]) { 
                result_index1 = i; 
                break;
            }
        }

        for (int i=(int)v.size()-1;i >= 0;--i) {
            if (numbers[i] == v[right]) {
                result_index2 = i; 
                break; 
            }
        }

        if (result_index1 > result_index2) 
            swap(result_index1,result_index2);

        vector<int> result {result_index1 + 1, result_index2 + 1};
        return result;
    }
};