LeetCode #1 TwoSum 哈希表双指针

最新推荐文章于 2024-11-09 14:26:40 发布

aibin6833

最新推荐文章于 2024-11-09 14:26:40 发布

阅读量105

点赞数

文章标签： runtime 数据结构与算法

原文链接：http://www.cnblogs.com/Bw98blogs/p/8058931.html

版权

Description

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].

思路

　　首先我们想到的是暴力法，两个 for 循环求解，时间复杂度为O(n^2)

//Runtime: 106 ms
//First thought: BF
class Solution {
    public:
    vector<int> twoSum(vector<int>& nums, int target) {             
        int i,j;
        vector<int> ret {0, 1};
        for (i = 0; i< nums.size(); ++i) {
            ret[0] = i;
            for(j = i+1; j < nums.size(); ++j){
                if (nums[i] + nums[j] == target) 
                {    
                    ret[1] = j;
                    return ret;
                }                                                          
            }                                                              
        }                                 
    }                                                                    
};

　　但是，我发现时间消耗太多了，所以借鉴当时“换硬币”、“爬楼梯”问题的优化方法，由于num[i]、num[j]、target都是定值，所以在条件判断里不需要每次都进行加运算

//Runtime: 79 ms
//Because nums[i], nums[j], target are fixed values, we do not need to do additions every time
class Solution {
    public:
    vector<int> twoSum(vector<int>& nums, int target) {             
        int i,j;
        vector<int> ret {0, 1};
        for (i = 0; i< nums.size(); ++i) {
            ret[0] = i;
            int tar = target - nums[i];
            for(j = i+1; j < nums.size(); ++j){
                if (nums[j] == tar) 
                {    
                    ret[1] = j;
                    return ret;
                }                                                          
            }                                                              
        }                                 
    }                                                                    
};

　　AC后，看了 Discuss 里头的方法以及娄神的博客，我采用了更复杂的数据结构散列表（HashTable）以降低时间复杂度，我的想法是这样：如果想只扫描一遍数组就得出结果，那么肯定就要有一部字典，边扫描边存储值，在这里存储的不是数组当前的值，而是“目标值 - 当前值”，我们称之为对象值。

　　也就是说，字典里存储的是每个数据所希望的”另一半“的大小。所以，字典的 Key 是对象值，字典的 Value 是数组索引。然后我们再往后扫描，如果扫描到的值的另一半出现在了字典里，那么说明当前值是”上一半“所需要的”下一半“，此时将它们的索引存储在 ret[0]、ret[1]中并返回；如果没有字典里没有出现它的另一半，那么把对象值和当前索引继续存储字典中。

　　该算法的时间复杂度为 O(n)

//Runtime: 6 ms

#include<unordered_map>
using std::unordered_map;

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {             
        unordered_map<int,int> um;
        vector<int> res(2);
        int i;
        int n = nums.size();
        for (i = 0; i < n; ++i) {
            if (um.find(target - nums[i]) != um.end()) {
                res[0] = um[target - nums[i]];
                res[1] = i; 
                return res;  
            }
            else {
                um[nums[i]] = i;          
            }            
        }
        um.clear();
    }   
};

　　补充一种双指针遍历有序数组的方法

TwoNumberSum (S, x)
    mergeSort (S, 1, n)
    i = 1
    j = n
    while i < j
        if A[i] + A[j] == x
            return true            
        if A[i] + A[j] < x
            i = i + 1
        if A[i] + A[j] > x
            j = j - 1
    return false