1.两数之和

python解法

1、暴力解法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        size=len(nums)
        for i,m in enumerate(nums):
            j=i+1
            while j<size:
                if target==(m+nums[j]):
                    return [i,j]
                else:
                    j+=1

遍历数组 时间复杂度O（n），查找target=m+num[j]，时间复杂度O（n）,因此时间复杂度为O（n^2),空间复杂度O（1）

2两遍哈希表

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        _dict={}
        for i, m in enumerate(nums):
            _dict[m]=i
        for i,m in enumerate(nums):
            j=_dict.get(target-m)
            if j is not None and i!=j:
                return [i,j]
        时间复杂度O（n），空间复杂度O（n）

3一遍哈希表

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        _dict={}
        for i, m in enumerate(nums):
            
            if _dict.get(target-m) is not None :
                return [_dict.get(target-m),i]
            _dict[m]=i
            时间复杂度O（n），空间复杂度O（n）

 

c++解法

1

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

 

2两遍哈希表

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
      map<int,int> a;
        
      vector<int> b(2,-1);
        for(int i=0;i<nums.size();i++)
        {
            a.insert(map<int,int>::value_type(nums[i],i));
            
        }
        for(int i=0;i<nums.size();i++)
        {
            if(a.count(target-nums[i])>0 && a[target-nums[i]]!=i)
            {
                b[0]=i;
                b[1]=a[target-nums[i]];
                break;
            }
        }
        return b;
    }
};

3

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