两数之和(c++ 、c)

题目介绍

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

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

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

示例1：

• 输入：nums=【2，7，11，1】，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]

提示

• 2<= nums.length <= 10⁴
• -10⁹ <=nums[i] <= 10⁹
• -10⁹ <=target <= 10⁹
• 只会存在一个有效答案

###你可以想出一个时间复杂度小于O（n²)的算法吗？

方法一

思路及算法

最容易想到的方法是枚举数组中的每一个数x，寻找数组中是否存在target-x。
当我们使用遍历整个数组的方法寻找target-x时，需要注意到每一个位于x之前的元素都已经和x匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在x后面的元素中寻找target-x

C++

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

c

int* twoSum(int* nums, int numsSize,int target,int* returnSize){
	int i , j ;
	int *result= NULL;
	*returnSize=2
	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 result;
}

注：malloc是c语言中的动态分配内存，result=（int*)malloc(sizeof(int)2);malloc函数返回的是void*型，所以要强制类型转换成int，在前面加上（int），才能给整型赋值，后面（sizeof（int）*2）的意思是分配两个int大小的空间
总结：该方法简单，但是时间复杂度为O（n²).空间复杂度为O（1）；运行速度慢且内存空间消耗大

复杂度分析

• 时间复杂度：O（N²),其中N是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次
• 空间复杂度：O（1）

方法二：哈希表

什么是哈希表

散列表（Hash table，也叫哈希表），是根据关键码值(Key value）而直接进行访问的 数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的 数组叫做散列表

哈希表：直接进行访问的数据结构

思路及算法

注意到方法一的时间复杂度较高的原因是寻找target-x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。

使用哈希表，可以将寻找target-x 的时间复杂度降低到从O（N）降低到O（1）

这样我们创建了一个哈希表，对于每一个x，我们首先查询哈希表中是否存在target-x,然后将** x** 插入到哈希表中，即可保证不会让x和自己匹配

使用哈希表有如下步骤

1、算出当前数字和目标数字的差
2、检查哈希表中是否存在该差，存在，则返回结果
3、不存在，当前数字作为key，索引作为value存入哈希表

1、nums为3时，和target差值为3，哈希表中未找到3，将当前数3和索引0放入哈希表存放
2、算出当前数字和目标数字的差
3、检查哈希表中是否存在该差，存在，则返回结果
4、不存在，当前数字作为key，索引作为value存入哈希表

1、当nums为2时，和target差值为4，哈希表中未找到4，将当前数2和索引1放入哈希表存放
2、算出当前数字和目标数字的差
3、检查哈希表中是否存在该差，存在，则返回结果
4、不存在，当前数字作为key，索引作为value存入哈希表

1、当nums为4时，和target差值为2，哈希表中存在2，返回结果[1,2]
2、算出当前数字和目标数字的差
3、检查哈希表中是否存在该差，存在，则返回结果
4、不存在，当前数字作为key，索引作为value存入哈希表

C++中unordered_map用法

• unordered_map 是一个将key 和value 关联起来的容器，它可以高效的根据单个key值查找对应的value
• key值应该是唯一的，key和value的数据类型可以不相同
• unordered_mao存储元素时是没有顺序的，只是根据key的哈希值，将元素存在指定位置，所以根据key查找单个value时非常搞笑，平均可以在常数时间内完成
• unordered_map查询单个key的时候效率比map高，但是要查询某一范围内的key值时比map效率低
• 可以使用[]操作符来访问key值对应的value值

class  Solution{
public：
	vector<int>twoSum(vector<int>& nums, int target){
		unordered_map<int , int > hashtable ;
		for( int i=0 ;i < nums.size() ;++i){
			auto it=hashtable.find(target-nums [ i ]);
			if ( it ! =hashtable.end() ){
				return { it->second, i};
			}
			hashtable [ nums [ i ] = i;
		}
		return {};
	}

C

struct hashTable{
	int key;
	int val;
	UT_hash_handle hh;
};
struct hashTable* hashtable;

struct hashTable* find(int ikey) {
	struct hashTable* tmp;
	HASH_FIND_INT(hashtable, &ikey ,tmp);
	return tmp;
}

void insert(int ikey,int val){
	struct hashTable* it=find(ikey);
	if(it==NULL){
		struct hashTable* tmp=malloc(sizeof(struct hashTable));
		tmp->key=ikey;
		tmp->val=ival;
		HASH_ADD_INT(hashtable,key,tmp);
	}else{
		it->val=ival;
	}
}

int* twoSum(int* nums, int numsSize,int target,int* returnSize) {
	hashtable =NULL;
	for( int i=0;i<numsSize;i++){
		struct hashTable* it=find(target-nums[i]);
		if(it!=NULL){
			int* ret=malloc(sizeof(int)*2);
			ret[0]=it->val;
			ret[1]=i;
			*returnSize=2;
			return ret;
			}
			insert(nums[i],i );
		}
		*returnSize=0;
		return NULL;
}

复杂度分析

-时间复杂度：O（N），其中N是数组中的元素数量。对于每一个元素 x，我们可以O（1）地寻找 target -x

-空间复杂度： O（N），其中N是数组中的元素数量，主要为哈希表的开销

方法三：两遍哈希表

class Solution{
public:
	vector<int> twoSum (vector< int >& nums,int target){
		map< int, int> a; // 建立hash表存放数组元素
		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;
	};
};

注：该方法用map实现，map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力