LeetCode 1.TwoSum

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:

//给定 nums = [2, 7, 11, 15], target = 9
//因为 nums[0] + nums[1] = 2 + 7 = 9
//所以返回 [0, 1]

方法一、枚举法，先贴上我的第一个代码，直接用两次循环来遍历实现两数相加

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

运行之后用时104ms 达到34.10%。
而且我很好奇的并不是那些用时短的，反而是其他比这个时间还长的人的代码是怎么写的。
方法二、然后尝试第二种方法，用相减的值与数组进行判断：

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

这次用时136ms，排名14.95%.到这个时候基本已经不知道还有什么方法可以增加时间复杂度了。
然后可以排名靠前点的算法，我想到了用hash表，其实hash表是方法二的改进，这里我们直接把值放在hash表中，省掉了循环。

方法三、hash原理
先取一段len长度的hash表，len为数组中最小的数min和符合条件的最大数max（由目标数减去最小数确定）之差。将满足条件的数组元素放入Hash表中，通过hash表中target-nums[i]-min来确定是否已经找到满足条件的下标，使用Hash法可以把时间复杂度降低到O(n)，不过在数组内值差别很大时不太适合此方法。例如数组有两个元素[-1000,1000],，分配空间就太大，效率不高。

int* twoSum(int* nums, int numsSize, int target) {  
    int min = 2147483647;  
    int i = 0;  
    for (i = 0; i < numsSize; i++) {  
        if (nums[i] < min)  
            min = nums[i];  
    }  
    int max = target - min;   
    int len = max - min + 1;   //确定hash长度  
    int *table = (int*)malloc(len*sizeof(int));  
    int *indice = (int*)malloc(2*sizeof(int));  
    for (i = 0; i < len; i++) {  
        table[i] = -1;         //hash初值  
    }  
    for (i = 0; i < numsSize; i++) {  
        if (nums[i]-min < len) {  
            if (table[target-nums[i]-min] != -1) {        //满足相加为target  
                indice[0] = table[target-nums[i] - min];  
                indice[1] = i;  
                return indice;  
            }  
            table[nums[i]-min] = i;  
        }  
    }  
    free(table);  
    return indice;  
}  

运行用时32ms,排名94.07%。
到这里本菜鸡基本完成了自己的代码，希望可以得到更多人的思路，欢迎留言。