1.Two Sum

1.Two Sum

Given an array of integers, return indices of the two numbers such that they add up to a specific target.You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

题解一：

　　采用哈希表。判断两个数之合是否是target------xi+xj=target=>xi=target-xj，我们可以将问题转化为找一个数是否在数组中。

代码：

 python

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        hashdict={}
        
        for i,item in enumerate(nums):
            if(target-item) in hashdict:
                return (hashdict[target-item],i)
            hashdict[item]=i
        return []

 C++

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>result;
        int length=nums.size();
        if(length<2)return result;
        //创建哈希表
        unordered_map<int,int>hash(length);
        
        for(size_t i(0);i<length;i++){
            if(hash.find(target-nums[i])!=hash.end()){
                result.push_back(hash[target-nums[i]]);
                result.push_back(i);
                return result;
            }
            else{
                hash[nums[i]]=i;
            }
        }
        return result;
    }
};

题解二  --- 排序后使用两个指针

先对数组进行排序，然后使用两个指针分别指向首尾元素，逐步向中间靠拢，直至找到满足条件的索引。

代码：

C++

class Solution {
public:
    /*
     * @param numbers : An array of Integer
     * @param target : target = numbers[index1] + numbers[index2]
     * @return : [index1+1, index2+1] (index1 < index2)
     */
    vector<int> twoSum(vector<int> &nums, int target) {
        vector<int> result;
        const int length = nums.size();
        if (0 == length) {
            return result;
        }

        // first num, second is index
        vector<pair<int, int> > num_index(length);
        // map num value and index
        for (int i = 0; i != length; ++i) {
            num_index[i].first = nums[i];
            num_index[i].second = i + 1;
        }

        sort(num_index.begin(), num_index.end());
        int start = 0, end = length - 1;
        while (start < end) {
            if (num_index[start].first + num_index[end].first > target) {
                --end;
            } else if(num_index[start].first + num_index[end].first == target) {
                int min_index = min(num_index[start].second, num_index[end].second);
                int max_index = max(num_index[start].second, num_index[end].second);
                result.push_back(min_index);
                result.push_back(max_index);
                return result;
            } else {
                ++start;
            }
        }

        return result;
    }
};

源码分析

1. 异常处理。
2. 使用length保存数组的长度，避免反复调用nums.size()造成性能损失。
3. 使用pair组合排序前的值和索引，避免排序后找不到原有索引信息。

4. 使用标准库函数排序。

复杂度分析

遍历一次原数组得到pair类型的新数组，时间复杂度为 O(n)，空间复杂度也为 O(n)，标准库中的排序方法时间复杂度近似为 O(nlogn)两根指针遍历数组时间复杂度为 O(n)