力扣（LeetCode）刷题笔记

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

注：你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法一（C之暴力法）：

注：执行用时196ms，内存消耗7.5M

int* twoSum(int* nums, int numsSize, int target, int* returnSize)   //numsSize为数组元素个数
{
    *returnSize = 2;  //返回值的个数为2
    int i,j;
    int* result = NULL;
    for(i = 0; i < numsSize-1; ++i)
    {
        for(j = i+1; j < numsSize; ++j)
        {
            if(nums[i] + nums[j] == target)
            {
                result = (int*)malloc(sizeof(int)*2); //给整形指针开辟空间，其相当于一个整形数组
                result[0] = i;
                result[1] = j;
                return result; //找到和为目标值的那两个整数，返回他们的数组下标
            }
        }
    }
    return 0;
}

 

解法二（C++之暴力法）：

注：执行用时212ms，内存消耗9.2M

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int n = nums.size();
        vector<int> result;
        for(int i = 0; i < n-1; ++i)
        {
            for(int j = i+1; j < n; ++j)
            {
                if(nums[i]+nums[j] == target)
                {
                    result.push_back(i);
                    result.push_back(j);
                    return result;  //找到和为目标值的那两个整数，返回他们的数组下标
                }
            }
        }
        return result;
    }
};

 

解法三（C++之两遍哈希表）：

一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素（target - nums[i]target−nums[i]）是否存在于表中。注意，该目标元素不能是 nums[i]nums[i] 本身！

注：执行用时16ms，内存消耗10.5M

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int n = nums.size();
        map<int,int> array;  //建立hash表存放数组元素
        vector<int> result(2,-1);  //存放结果，初始化为两个-1
        for(int i = 0; i < n; ++i)
        {
            int x = target - nums[i];
            if(array.count(x) > 0)
            {
                result[0] = array[x];
                result[1] = i;
                break;
            }
            array[nums[i]] = i;
        }
        return result;  //找到和为目标值的那两个整数，返回他们的数组下标
    }
};

 

解法四（C++之一遍哈希表）：

注：执行用时12ms，内存消耗10.3M

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int n = nums.size();
        map<int,int> array;  //建立hash表存放数组元素
        vector<int> result(2,-1);  //存放结果，初始化为两个-1
        for(int i = 0; i < n; ++i)
        {
            int x = target - nums[i];
            if(array.count(x) > 0)
            {
                result[0] = array[x];
                result[1] = i;
                break;
            }
            array[nums[i]] = i;
        }
        return result;  //找到和为目标值的那两个整数，返回他们的数组下标
    }
};