LeetCode 1：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

解题思路

思路一：两层循环，依次判断数组中两个元素的和是否等于target。时间复杂度为O(n²)，空间复杂度为O(1)，代码如下：

class Solution {
 public:
     vector<int> twoSum(vector<int> &numbers, int target) {
         vector<int> result;
         for (int i = 0; i < numbers.size()-1; i++) {
             for (int j = i+1; j < numbers.size(); j++) {
                 if (numbers[i] + numbers[j]==target) {
                     result.push_back(i+1);
                     result.push_back(j+1);
                     return result;
                 }
             }
         }
         return result;
     }
 };

思路二：首先对数组进行排序，然后使用两个指针从数组首尾开始遍历。这两个指针指向的元素之和若小于target的值，则首指针加1；若大于target的值，则尾指针减1；若相等则返回这两个元素在原数组中的下标。时间复杂度为O(nlog(n))，空间复杂度为O(n)，代码如下：

struct Node {
    int num;
    int pos;  // num在原数组中的下表
};

bool cmp(Node a, Node b) {
    return a.num < b.num;
}

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> result;

        vector<Node> array;
        for (int i = 0; i < numbers.size(); i++) {
            Node temp;
            temp.num = numbers[i];
            temp.pos = i;
            array.push_back(temp);
        }

        sort(array.begin(), array.end(), cmp); // 排序

        //i为首指针，j为尾指针
        for (int i = 0, j = array.size() - 1; i != j;) {
            int sum = array[i].num + array[j].num;
            //相等，返回
            if (sum == target) {
                if (array[i].pos < array[j].pos) {
                    result.push_back(array[i].pos + 1);
                    result.push_back(array[j].pos + 1);
                } 
                else {
                    result.push_back(array[j].pos + 1);
                    result.push_back(array[i].pos + 1);
                }
                break;
            } 
            else if (sum < target) {
                //两个指针指向的元素之和若小于target的值，则首指针加1
                i++;
            } 
            else if (sum > target) {
                //两个指针指向的元素之和若大于target的值，则尾指针减1
                j--;
            }
        }
        return result;
    }
};

思路三：将数组中的元素存入hash表中，键值对为<value, index>。遍历数组，通过hash表判断 target - numbers[i] 是否存在，若存在返回hash表中存放的下标即可。时间复杂度为O(n)，空间复杂度为O(n)，代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> ret(2,-1);
        unordered_map<int, int> m;    //value->index map
        for(int i = 0; i < numbers.size(); i ++)
        {
            if(m.find(target-numbers[i]) == m.end())
                //target-numbers[i] not appeared
                m[numbers[i]] = i;
            else
            {
                ret[0] = m[target-numbers[i]]+1; 
                ret[1] = i+1;
                return ret;
            }
        }
    }
};