Leetcode刷题1（C++） 两数之和

题目描述

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

```cpp
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

这是我刷题的第一题，不太清楚Leetcode怎么用。所以花了不少时间。

暴力解法

执行时间：400ms
内存消耗：9.9MB

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

哈希表解法1

思路：利用哈希表直接搜索，将数组元素存放在哈希表中，然后在哈希表中查找target 与数组元素的差值相同的数。

执行时间：20ms
内存消耗：12.1MB

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
         // 利用map容器
        int N, j;
        N = nums.size();
        map<int, int> m;
        vector<int> v;
        // 将vector数据写入map容器中
        for(int i = 0; i < N; ++i)
        {
            m[nums[i]] = i;
        }

        // 利用差值找到所在位置
        for(int i = 0; i < N; ++i)
        {
            
            if(m.find(target - nums[i]) != m.end())
            // 判断语句还可以使用count函数
            // m.count(target - nums[i]) != 0;
            // count函数统计 有多少个中的值
            {
                j = m[target - nums[i]];
                if(  j!=i )
                {
                    v.push_back(i);
                    v.push_back(j); 
                    break; 
                    // 找到就立马跳出  没有break，会循环所有数
                    // 假设所在位置为[0,1] ，实际输出：[0，1，1，0] 
                }                 
                
            }
              
        }
        return v;            
    }
};

哈希表解法2

思路：哈希解法1中，元素存放在哈希表中；是否是重复元素的判断；其实完全没必要走这两步。
只需要判断差值在不在数组中，来替代数组元素存放在哈希表
一直向后遍历不回头，就不会有出现重复元素的情况

执行时间：12ms
内存消耗：10.8MB

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

哈希表解法3

采用代码随想录想法
思路：哈希表的不同也会影响程序运行的速度。明显这题不需要key值有序，所以选择unordered_map效率更高。
执行时间：4ms
内存消耗：10.5MB

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        unordered_map<int, int> m;
        for(int i = 0; i < nums.size(); ++i)
        {
            auto iter = m.find(nums[i]);
            if(iter != m.end())
            {
                return {iter->second, i};
                break;
            }
            m.insert(pair<int, int>((target - nums[i]), i));
        } 
        return {};     
    }
};