LeetCode 1.两数相加

C++

一、暴力美学

没有必要做更多解释，穷举就完了

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

二、建立Hash表、遍历

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> v;
        map<int, int> mp;
        for (int i = 0; i < nums.size(); i++) //建立值和索引的映射
        {
            mp[nums[i]] = i;
        }
        for (int j = 0; j < nums.size(); j++)//开始遍历
        {
            if (mp.find(target - nums[j]) != mp.end())//查找是否存在target-nums[j]，如果查找不到则得到end的迭代器
            {
                if (j != mp[target - nums[j]])//排除等于自身的情况
                {
                    v.push_back(j);
                    v.push_back(mp[target - nums[j]]);
                    return v;
                }
            }
        }
        return v;
    }
};

三、遍建立Hash表遍遍历

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> v;
        map<int, int> mp;
        for (int i = 0; i < nums.size(); i++)//开启遍历
        {
            if (mp.find(target - nums[i]) != mp.end())//如果查找到了target-nums[i]，迭代器不等于map.end()
            {
                v.push_back(mp[target - nums[i]]);
                v.push_back(i);
                return v;
            }
            mp[nums[i]] = i;//查找失败，扩充迭代器
        }
        return v;
    }
};

思考：第一二三种方法的区别。

• 第一种方法，反复循环，时间复杂度为$O(n^2)$，但是空间复杂度最低；
• 第二种方法，以空间换时间，建立值与索引的映射，利用map.find(target-(nums[i]))直接查找；
• 第三种方法，一遍建立映射一遍进行查找，能够节省时间。

在第三个代码中可以将map换为unordered_map，unordered_map的建立比较慢，但是查找的过程比较快，能够节省时间。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> v;
        unordered_map<int, int> mp;
        for (int i = 0; i < nums.size(); i++)//开启遍历
        {
            if (mp.find(target - nums[i]) != mp.end())//如果查找到了target-nums[i]，迭代器不等于map.end()
            {
                v.push_back(mp[target - nums[i]]);
                v.push_back(i);
                return v;
            }
            mp[nums[i]] = i;//查找失败，扩充迭代器
        }
        return v;
    }
};

以上的代码能够比第三种和第二种快一些