func twoSum

202106 再次遇到这个题，新的代码

func twoSum(nums []int, target int) []int {

result := make(map[int]int)

for key,value:= range nums{

if vv, ok := result[target-value];ok{

return []int{vv,key}

}else{

result[value] = key

}

}

return []int{}

 

}

----

这是leetcode上的一题，忘记之前最初的想法是什么样的了，最终提交的是这一版本，理解思路：

golang语言类型可以不是连续的，所有考虑用这种方法：将i和value更换，在更新new_nums的同时，检测target-value下标的值是否存在，来进行判断，空间和时间复杂度都变小了、

func twoSum(nums []int, target int) []int {
    new_nums := make(map[int]int)
    a := []int{-1, -1}
    for i, value := range nums{
        num, exsited := new_nums[target - value]
        if exsited{
            a[0] = num
            a[1] = i
        }else{
            new_nums[value] = i
        }
    }
    return a
}
 

今天尝试用c语言重新写了下，调试了好久，问题一直不过，都不知道问题出在哪，最终发现问题出现理解参数的过程，returnSize是返回参数的个数，不是直接返回returnSize，之前直接给returnSize申请空间、返回，全部都错了，果然需要把c基础再看一遍。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int* res = (int *)malloc(sizeof(int) * 2);
    memset(res, -1, 2);
    int i=0, k=0;
    *returnSize = 0;
    if(numsSize <= 0)
        return res;
    int *b = (int *)malloc(sizeof(int) * numsSize);
    for(i=0; i<numsSize;i++){
        if(i >= 1){
            k = i - 1;
            while(k >= 0){
                if(nums[k] == b[i-1]){
                    res[0] = k;
                    res[1] = i-1;
                    i = numsSize - 1;
                    *returnSize = 2;
                    break;
                }
                k--;
            }
        }
        b[i] = target - nums[i];
    }
    return res;
}

 int main(){
    int *return_size;
    int *nums = (int *)malloc(sizeof(int) * 10);
    //nums = [2,7,11,15];
    int i=0;

    nums[0] = 2;
    nums[1] = 7;
    nums[2] = 11;
    nums[3] = 15;
    return_size = twoSum(nums, 4, 9, return_size);
    for(i=0;i<4;i++){
        printf("%d\n", return_size[i]);
    }
    return 0;
}