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++会是一个不错的选择，大家可以试着去写写相关的代码。