LEETCODE（力扣）1. 两数之和

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

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

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

示例 1：

输入：nums = [2,7,11,15], 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 <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

1.自解

方法一，双重for循环

时间、空间复杂度都比较差
最纯粹的暴力遍历，使用了两个for循环

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int*p=(int *)malloc(sizeof(int)*2);
    int num1=0,num2=0;
    for(int i=0;i<numsSize;i++)
    {
        for(int j=i+1;j<numsSize;j++)
        {
            if(nums[i]+nums[j]==target)
            {
                p[0]=i;
                p[1]=j;
                *returnSize=2;
                return p;
            }
        }
    }
    *returnSize=0;
    return NULL;

}

方法二：哈希表

参考了官方解答，但是自己写的
简单的来说就是遍历一次数组，将没能成功组成目标数的数用一个链表储存起来，遇到新的数直接和链表里的数进行匹配，匹配到就直接输出，未匹配到就加入链表。
第一次写的时候只使用了头节点，因此插入链表尾部也要遍历一次链表，花费时间较多

第二次的时候用了一个尾节点，新元素直接插入链表尾部，节省了许多时间

与官方解答对比可以发现差不多，不过官方使用了HASH_ADD_INT与HASH_FIND_INT两个库函数，但是时间直接快到3ms，只能说库函数伟大，无需多言，要拒绝重复造轮子

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
struct hashtable{//链表的节点
    int key;
    int val;
    struct hashtable*next;
};
struct hashtable *head=NULL;//头部
struct hashtable *tail=NULL;//尾部
struct hashtable* hashtable_find(int val)//遍历链表内查找
{
    struct hashtable *temp=head;
    while(temp!=NULL&&temp->val!=val)temp=temp->next;
    return temp;
}
void hashtable_insert(struct hashtable* insert_ht)//新节点插入尾部
{
    if(head==NULL)
	{
		head=insert_ht;
		tail=insert_ht;
		return ;
	}
    struct hashtable *temp=head;
    tail->next=insert_ht;
    tail=insert_ht;
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int *r=(int *)malloc(sizeof(int)*2);
    struct hashtable* temp;
    head=NULL;
    for(int i=0;i<numsSize;i++)
    {
        if((temp=hashtable_find(target-nums[i]))!=NULL)//链表中查到与匹配节点
        {

            r[0]=i;
            r[1]=temp->key;
            *returnSize=2;
            return r;
        }
        else
        {//无匹配节点，当前数插入链表
            temp=(struct hashtable *)malloc(sizeof(struct hashtable));
            temp->key=i;
            temp->val=nums[i];
            temp->next=NULL;
            hashtable_insert(temp);
        }
    }
    return r;
}

官方解

哈希表，用到了库函数

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 ival) {
    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;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/two-sum/solutions/434597/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。