LeetCode: Two Sum

最新推荐文章于 2019-01-03 13:40:30 发布

原创最新推荐文章于 2019-01-03 13:40:30 发布 · 263 阅读

0 ·

CC 4.0 BY-SA版权

本文解析了“两数之和”问题的三种算法解决方法：双层搜索、改进后的二分搜索及哈希表解决方案。双层搜索的时间复杂度为O(n^2)，二分搜索的时间复杂度为O(nlogn)，而哈希表法的时间复杂度最优，为O(n)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：
这里写图片描述

解法一：
二层搜索，对每一个元素，在该元素之后的序列中搜索与之相加和为targetd的元素，时间复杂度为O(n^2)，Accepted的代码如下：

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

解法二：
从另一个角度出发，对每一个元素遍历，先求出target值与当前元素的差goal，在剩余的元素中搜索goal，将问题转化为一个直接查找的问题。然后用二分搜索法来提高算法的效率，这样，时间复杂度就变为o(nlogn)。但是，二分搜索法需要对元素进行排序，而本题要求的是返回两个和数的下标。为了解决这个问题，使用一个含有两个整数的结构体来保存数与下标之间的对应关系。另外，搜索goal值时应该排除掉当前正在遍历的和数，比如target值为6时，如果数组中存在3，就会出现返回两个相同下标的结果，因为这个问题WA了一次。最后被Accepted的代码如下：

struct node
{
    int num,index;
};
bool cmp(node a,node b)
{
    return a.num<b.num;
}

class Solution{
public:
    vector<int> twoSum(vector<int>& nums,int target){
    vector<int> results;
    vector<node> array;

    for(int i=0;i<nums.size();i++)
    {
        node temp;
        temp.num=nums[i];
        temp.index=i;
        array.push_back(temp);
    }
    sort(array.begin(),array.end(),cmp);

    for(int i=0;i<nums.size();i++)
    {
        int goal=target-nums[i];
        int low=0;
        int high=nums.size()-1;
        //二分查找
        while(low<=high)
        {
            int middle=(high-low)/2+low;
            if(array[middle].num==goal&&array[middle].index!=i)
            {
                results.push_back(i);
                results.push_back(array[middle].index);
                return results;
            }
            else if(array[middle].num>goal) high=middle-1;
            else low=middle+1;
        }
    }
    return results;
    }
}

解法三：
还有一种更高效的算法是哈希算法，哈希表可用STL里的map来实现。共循环一次，每次判断数组中当前遍历的值在不在哈希表里，若不在，则加入；若在，则在哈希表中用map的count函数找target-nums[i]，这个步骤的复杂度为o(1)，找出的值的下标一定小于i，设为n，则返回结果为[n,i]，找不到则继续循环。因此，这个算法的估计复杂度为o(n)。Accepted的代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> results;  
        map<int, int> hashmap;
        for(int i=0; i<nums.size(); i++)
        {  
            //如果下标为i的数不在哈希表里，则加入
            if(!hashmap.count(nums[i])) hashmap.insert(pair<int, int>(nums[i], i));
            //如果哈希表中存在差goal,则返回结果
            if(hashmap.count(target-nums[i]))
            {  
                int n=hashmap[target-nums[i]];  
                if(n<i)
                {  
                    results.push_back(n);  
                    results.push_back(i);  
                    return results;  
                }  
            }
        }
        return results;
    }
};