LeetCode——两数之和
题目
给定一个整数数组nums和一个目标值target,请你在该数组中找出和为目标值的那两个整数,并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是,数组中同一个元素不能使用两遍。
示例
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
方法1:暴力求解
暴力解法的思路很简单,就是将数组中的每个元素 x 遍历,并查找是否存在一个值与 target−x 相等的目标元素。双重 for 循环解决即可。代码如下:
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
int* result = (int*)malloc(sizeof(int)*2);//最终返回两个数的数组下标
for(int i =0;i<numsSize;i++){
int tem = target - nums[i];
for(int j =i+1;j<numsSize;j++){//数组中同一个远胜于不能使用两边
if(tem == nums[j]){
result[0] = i;
result[1] = j;
*returnSize = 2;
return result;
}
}
}
return result;
}
执行结果如下:
方法2:两遍哈希表求解
其实根据方法1的求解结果,可以发现其运行效率并不高。此时我们也应该想到,找出数组中是否存在目标解及与其相对应的数组下标,最好的方法应该是——哈希表。
利用两次迭代,在第一次迭代中,我们将每个元素的值和它的数组下标添加到表中;然后,在第二次迭代中,我们将检查每个元素所对应的目标元素(target−nums[i])是否存在于表中。==注意,该目标元素不能是 nums[i]本身!==代码如下:
//由于C语言中没有hashMap的实现,需要自己写一段map的简单实现代码
struct hash_data{
int key;
int data;
struct hash_data * next;
};
struct hash_table
{
struct hash_data ** head; //数组
int hash_width;
};
//初始化
int hash_init(struct hash_table * table, int width){
if(width<=0)
return -1;
struct hash_data **tmp = malloc(sizeof(struct hash_data *)*width);
table->head = tmp;
memset(table->head, 0, width * sizeof(struct hash_data *));
if(table->head==NULL)
return -1;
table->hash_width = width;
return 0;
}
//释放
void hash_free(struct hash_table table){
if(table.head!=NULL){
for (int i=0; i<table.hash_width; i++) {
struct hash_data* element_head= table.head[i];
while (element_head !=NULL) {
struct hash_data* temp =element_head;
element_head = element_head->next;
free(temp);
}
}
free(table.head);
table.head = NULL;
}
table.hash_width = 0;
}
int hash_addr(struct hash_table table,int key){
int addr =abs(key) % table.hash_width;
return addr;
}
//增加
int hash_insert(struct hash_table table,int key, int value){
struct hash_data * tmp = malloc(sizeof(struct hash_data));
if(tmp == NULL)
return -1;
tmp->key = key;
tmp->data = value;
int k = hash_addr(table,key);
tmp->next =table.head[k];
table.head[k]=tmp;
return 0;
}
//查找
struct hash_data* hash_find(struct hash_table table, int key){
int k = hash_addr(table,key);
struct hash_data* element_head=table.head[k];
while (element_head !=NULL) {
if ( element_head->key == key) {
return element_head;
}
element_head = element_head->next;
}
return NULL;
}
//依赖map实现
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
int* res = (int *)malloc(sizeof(int) * 2);
* returnSize=0;
struct hash_table table;
hash_init(&table, 100);
for (int i=0; i<numsSize; i++) {
hash_insert(table,nums[i] ,i);
}
for(int i = 0; i < numsSize; i++)
{
int value = target - nums[i];
struct hash_data* data= hash_find(table, value);
if (data !=NULL && data->data != i) {
res[1]=i;
res[0]=data->data;
* returnSize=2;
}
}
hash_free(table);
return res;
}
执行结果如下:
显然方法2的执行效率比方法1的要高,但是方法1的思路要简单,易于理解,代码也容易实现。相信绝大部人在处理这道题时,暴力解法是最先能够想到的一种思路。
其实本题还可以用一遍哈希表的思路来实现,方法2中释先把数组放到哈希表中,然后进行遍历。那其实我们也可以采用一边放一边遍历,直到找到目标解,此时便可以停止操作,直接返回结果即可。具体的实现大家可以自行去编一下代码。
有心人会发现,我在利用方法2求解的时候是通过C语言实现的,由于C语言中没有hashMap的实现,需要自己写一段map的简单实现代码。那其实JAVA或者C++会是一个不错的选择,大家可以试着去写写相关的代码。