leetcode第一题（两数之和）题解C语言

题目

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解析

第一次做leetcode，我寻思都不给数据范围的么==！题目给出一个整型范围内的数组和一个目标数，要求找出数组内和为该数的两个单元的下标，题目保证解存在且唯一，但是不能把同一个下标的数重复用两遍，即[2, 3, 4, 15], target = 6例子下答案不会是[1, 1]，但是[2, 3, 3, 15], target = 6例子下答案可以是[1, 2]，体会一下。

解法一：暴力法

直接二重循环遍历原数组，找到和为target后直接返回下标。O(n²)
（刚开始刷leetcode的同道们注意了哈，和其他OJ不同的是，leetcode只需要完成给出的函数即可，不需要输入输出，但是可以写其他函数，也可以定义全局变量（不知道是否会和没给出的部分冲突），宏定义、结构体定义等等；除了返回必要的参数外，结尾一定要再return一次，也不知道为什么，但一定这样才不会出错）

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int *result = (int*)malloc(sizeof(int) * 2);
    int i, j;
    for(i = 0; i < numsSize; i++) {
        for(j = i + 1; j < numsSize; j++) {
            if(nums[i] + nums[j] == target) {
                result[0] = i;
                result[1] = j;
                *returnSize = 2;
                return result;
                //break;
            }
        }
    }
    return 0;//这里一定要再返回一次不知道为什么
}

解法二：hash

对数组做一个hash，然后遍历整个数组，对于下标i，去hash查找target - nums[i]是否在数组中。（注意hash容量10007不够，但100003是够的）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
#define PN 100003
int hash[PN];
int hash_index[PN];
void hash_insert(int key, int index) {
    int t = abs(key) % PN;
    while(hash_index[t] >= 0) t = (t + 1) % PN;
    hash[t] = key;
    hash_index[t] = index;
}
int inhash(int key) {
    int t = abs(key) % PN;
    while(hash_index[t] >= 0) {
        if(hash[t] == key) return hash_index[t];
        else t = (t + 1) % PN;
    }
    return -1;
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int i, j;
    int *result = (int*)malloc(sizeof(int) * 2);
    for(i = 0; i < PN; i++) hash_index[i] = -1;
    for(i = 0; i < numsSize; i++) {
        hash_insert(nums[i], i);
    }
    for(i = 0; i < numsSize; i++) {
        int t = target - nums[i];
        int index = inhash(t);
        if(index >= 0 && index != i) {
            result[0] = i;
            result[1] = index;
            *returnSize = 2;
            return result;
        }
    }
    return 0;
}

突发奇想其实hash的时候可以把数字看出字符串用字典树查找，不过速度上没啥用

（map直接搞定只是想试一试）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
typedef struct node *Trie;
struct node {
    int key;
    Trie next[11];
};
Trie root;
char* convert(int number) {
    char *ret = (char*)malloc(15);
    char *str1 = (char*)malloc(15);
    int len = 0;
    int flag = 0;
    if(number < 0) {
        flag = 1;
    }
    number = abs(number);
    str1[len++] = (number % 10) + '0';
    number /= 10;
    while(number != 0) {
        str1[len++] = (number % 10) + '0';
        number /= 10;
    }
    int i = 0, j = len - 1;
    if(flag) ret[i++] = '-';
    while(j >= 0) {
        ret[i] = str1[j];
        i++; 
        j--;
    }
    ret[i] = '\0';
    return ret;
}
void trie_insert(char *name, int len, int index) {//字典树插入
    Trie p = root;
    int i, j;
    for(i = 0; i < len; i++) {
        int k;
        if(name[i] == '-') k = 10;
        else k = name[i] - '0';
        if(p->next[k] == NULL) {
            p->next[k] = (Trie)malloc(sizeof(struct node));
            for(j = 0; j < 11; j++) p->next[k]->next[j] = NULL;
            p->next[k]->key = -1;
        }
        p = p->next[k];
    }
    p->key = index;
}
int trie_find(char *name, int len) {//字典树查找
    Trie p = root;
    int i;
    for(i = 0; i < len; i++) {
        int k;
        if(name[i] == '-') k = 10;
        else k = name[i] - '0';
        if(p->next[k] == NULL) return -1;
        p = p->next[k];
    }
    return p->key;
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    *returnSize = 2;
    int *result = (int*)malloc(sizeof(int) * 2);
    int i, j;
    
    root = (Trie)malloc(sizeof(struct node));
    for(i = 0; i < 11; i++) root->next[i] = NULL;
    for(i = 0; i < numsSize; i++) {
        char *str;
        str = convert(nums[i]);
        int len = 0;
        while(str[len] != '\0') len++;
        trie_insert(str, len, i);
        free(str);
    }
    for(i = 0; i < numsSize; i++) {
        int t = target - nums[i];
        char *str;
        str = convert(t);
        int len = 0;
        while(str[len] != '\0') len++;
        int index = trie_find(str, len);
        free(str);
        if(index >= 0 && index != i) {
            result[0] = i;
            result[1] = index;
            return result;
        }
    }
    return 0;
}

解法三：排序+双下标

暴力法浪费时间的原因是数组无序，如果数组有序(从小到大)，可以一个从前往后一个从后往前遍历，每次检查nums[i] + nums[j]是否为target，如果是结束；否则，如果大了j前移使和减小，如果小了i后移使和增大；算法正确性：因为解存在所以一定可以找到，其次按照这种遍历，i和j一定在最终解的两侧，否则按照有序性和一定大于或小于target。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int cmp(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    *returnSize = 2;
    int *result = (int*)malloc(sizeof(int) * 2);
    int *copy = (int*)malloc(sizeof(int) * numsSize);
    int i, j, k;
    for(i = 0; i < numsSize; i++) copy[i] = nums[i];
    qsort(nums, numsSize, sizeof(nums[0]), cmp);
    i = 0;
    j = numsSize - 1;
    while(i < j) {
        int t = nums[i] + nums[j];
        if(t == target) {
            break;
        } 
        else {
            if(t > target) j--;
            else i++;
        }
    }
    for(k = 0; k < numsSize; k++) {
        if(copy[k] == nums[i]) {
            result[0] = k;
            break;
        }
    }
    for(k = 0; k < numsSize; k++) {
        if(copy[k] == nums[j] && k != result[0]) {//这里注意题目分析中说的
            result[1] = k;
            break;
        }
    }
    return result;
    return 0;
}

第一次刷leetcode，代码小白，不足之处。还望同道们指正