力扣刷题

给定一个整数数组 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 twoSum(vector& nums, int target)
{
int n = nums.size();
vector 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 twoSum(vector& nums, int target)
{
int n = nums.size();
map<int,int> array; //建立hash表存放数组元素
vector 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 twoSum(vector& nums, int target)
{
int n = nums.size();
map<int,int> array; //建立hash表存放数组元素
vector 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; //找到和为目标值的那两个整数，返回他们的数组下标
}
};