LeetCode题解——Two Sum

题目地址：https://oj.leetcode.com/problems/two-sum/

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

题目大意：

给定一个数组，找出其中两个数，它们的和等于给定的值。

函数返回这两个数的“下标”，下标按序排列，从1开始计算。

每个输入有且只有一个解。

分析：

①暴力解法。

　　求每两个元素的和，时间为O(n²)。

②先排序，后查找 或者 左右夹逼。

　　排序时间O(n logn)，由于需要记录下标和元素值的关系，空间复杂度O(n)。然后：

　　查找：对每一个元素a，二分查找target - a是否存在。总时间为O(n logn) + O(n logn) = O(n logn)；

　　夹逼：利用一对首尾指针求和，和<target，则首指针右移；和>target，则尾指针左移；相等则返回记录的下标值。总时间为O(n logn) + O(n) = O(n logn)。

③利用哈希表查找。

　　哈希表记录元素对应下标，对于元素a，O(1)时间查找target - a是否存在。总时间为O(n)。

程序挂掉的几个测试用例：

[5, 75, 25]  100      //排序之后下标顺序问题
[3, 2, 4]      6         //3 + 3 == 2 + 4  同一个元素被计算两次
[0, 4, 3, 0]  0         //0 + 0   元素重复，哈希表覆盖

代码：

 #include <iostream>
 #include <vector>
 #include <algorithm>
 #include <tr1/unordered_map>
 using namespace std;
 using namespace tr1;

 //②先排序，再夹逼。用一个辅助struct来记录数据和下标信息，并自定义比较函数，来对struct数组排序。
 struct node{
     int data;
     int index;
     node(int _data, int _index): data(_data), index(_index)
     {
     }
 };

 bool myCmp(node n1, node n2)
 {
     return n1.data < n2.data;
 }

 vector<int> twoSum1(const vector<int> &numbers, int target)
 {
     vector<int> result;

     if(numbers.empty())
     {
         return result;
     }

     vector<node> nv;   //space: O(N)
     for(int i = ; i < numbers.size(); ++i)  //time: O(N)
     {
         nv.push_back( node(numbers[i], i) );
     }

     sort(nv.begin(), nv.end(), myCmp);  //排序，time: O(NlgN)

     int hIdx = , tIdx = nv.size() - ;

     while(hIdx < tIdx)  //夹逼，time: O(N)
     {
         int sum = nv[hIdx].data + nv[tIdx].data;

         if(sum == target)
         {
             result.push_back(min(nv[hIdx].index, nv[tIdx].index) + );//min、max来确保下标顺序
             result.push_back(max(nv[hIdx].index, nv[tIdx].index) + );
             break;
         }
         else if(sum < target)
         {
             ++hIdx;
         }
         else
         {
             --tIdx;
         }
     } //while

     return result;
 }

 //③哈希表，由数据映射到下标，相同数据只记录最后一个下标。
 vector<int> twoSum2(const vector<int> &numbers, int target)
 {
     vector<int> result;

     if(numbers.empty())
     {
         return result;
     }

     unordered_map<int, int> num2loc;  //space: O(N)
     for(int i = ; i < numbers.size(); ++i)  //哈希映射，time: O(N)
     {
         num2loc[ numbers[i] ] = i;
     }

     for(int i = ; i < numbers.size() - ; ++i)  //查找，time: O(N)
     {
         int gap = target - numbers[i];

         if( num2loc.find(gap) != num2loc.end() && num2loc[gap] > i )
         {
             result.push_back(i + );
             result.push_back(num2loc[gap] + );
             break;
         }
     }

     return result;
 }

 int main()
 {
     int nums[] = {,,,};
     vector<int> numbers(nums, nums + sizeof(nums)/sizeof(*nums));
     int target = ;

     vector<int> result;

     result = twoSum1(numbers, target);
     for(int i = ; i < result.size(); ++i)
     {
         cout << result[i] << ' ';
     }
     cout << endl;

     result = twoSum2(numbers, target);
     for(int i = ; i < result.size(); ++i)
     {
         cout << result[i] << ' ';
     }
     cout << endl;

     return ;
 }