昨天剛刷了個leetcode簡單演算法兩數之和，結果發現自己第一遍耗時188ms(純屬暴力破解)，如下為我的程式碼：

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

之後我查看了下一些高手的程式碼，耗時100ms的程式碼其實跟我的是一樣的，只是可能測試的資料有些不同，不管這個，我在檢視10ms的程式碼時，發現用map來實現:，如下為10ms的程式碼：

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

發現時間複雜度為O(n)，比起之前的n*logn小多了，但當我檢視4ms的程式碼時，如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i,j,nsize;
        nsize=nums.size();
        vector<int> result;
        map<int,int> hmap;
        for(i=0;i<nsize;i++){
            if(hmap.find(target-nums[i])!=hmap.end()){
                j=hmap[target-nums[i]];
                result.push_back(j);
                result.push_back(i);
                break;
            }
            else
                hmap[nums[i]]=i;
        }
        return result;
    }
};
 

發現其實在查詢時可以不用先給map賦值，可以邊查詢邊賦值，這樣在大資料的情況下大大節省了不少時間。

以上程式碼轉載leetcode官網，僅供學習參考。