1.两数之和

题目：

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

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

最开始我用了最稚嫩的解法，用了两层循环去做

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    for(int i = 0; i <= numsSize-1; i++){
        for(int j = i+1; j <= numsSize - 1; j++ ){
            if(nums[i] + nums[j] == target){
                int* array = malloc(sizeof(int)*2);
                array[0] = i, array[1] = j;
                *returnSize = 2;
                return array;
            }
        }
    }
    *returnSize = 0;
    return NULL;
}

虽然它的空间复杂度是O(1)，但是时间复杂度到了O(N^2)

下面是官方用哈希表的做法

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;
}

没学过哈希表，学完在更新