LeetCode第一题(c语言）

　　这是一个简单的题，但是我一开始以*returnSize作为结果集返回，始终得不到需要的结果，

其实很明显returnSize本来翻译过来的意思就是返回结果集的大小而不是结果集。这里是暴力解法。

思想很简单，就是从数组中的第一个数开始，和其中剩下的其他的数相加看能否满足想要的target。

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

 这里是完整的两种解法

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#define IL inline
int cmp(const void *a,const void *b)
{
    return *(int *)a-*(int *)b;
}
int z;
/*
    LeetCode第1题 
*/ 

/*暴力解法 O(n^2)：
      从第一个数开始，将其与后面的每一个数相加，看能否等于target 
*/ 
int* twoSum1(int* nums, int numsSize, int target, int* returnSize){
    int* res = (int *)malloc(sizeof(int) * 2);
    int i,j;
    for (i = 0; i < numsSize-1; i++)
    {
        for(j = i + 1; j < numsSize; j++)
        {
            if(nums[i] + nums[j] == target)
            {
                *returnSize = 2;
                res[0] = i;
                res[j] = j;
                return res;
            }
        }
    }
    *returnSize = 0;
    return res;
}

/*
    排序后首位同步检测 O（nlogn）： 
        先将数组排序,然后首尾检测，
        若首尾之和大于target，则说明需要一个小一点的数看是否能够满足和等于target，于是右边往左移一个数
        若首尾之和小于target，则说明需要一个大一点的数看是否能够满足和等于target，于是左边往右移一个数 
*/ 
int* twoSum2(int* nums, int numsSize, int target, int* returnSize){
    int* res = (int *)malloc(sizeof(int) * 2);
    int* newNums = (int*)malloc(sizeof(int) * numsSize);
    int z;
    for(z = 0; z < numsSize; z++)
    {
        newNums[z] = nums[z];
    }
    qsort(newNums,numsSize,sizeof(int),cmp);
    int i = 0;
    int j = numsSize - 1;
    int k,sum;
    sum = newNums[i] + newNums[j];
    while(newNums[i] + newNums[j] != target) 
    {
        sum = newNums[i] + newNums[j];
        if(sum < target)
            i++;
        else if(sum > target)
        {
            j--;
        }
        if(i == j) 
        {
            *returnSize = 0;
            return res;
        }
    }
    *returnSize = 2;
    for(k = 0; k < numsSize; k++)
    {
        if(nums[k] == newNums[i])
        {
            res[0] = k;
            break;
        }    
    }
    for(k = numsSize - 1; k >= 0; k--)
    {
        if(nums[k] == newNums[j])
        {
            res[1] = k;
            break;
        }    
    }
    free(newNums); 
    return res;
}
// 测试
int main()
{
    int i;
    int nums[] = {3,2,4};
    int len = strlen(nums); 
    int target = 6;
    int* returnSize = (int *)malloc(sizeof(int));
    int* res;
    res = twoSum2(nums,len,target,returnSize);
    for(i = 0; i < *returnSize; i++)
    {
        printf("%d ",res[i]);
    }
    return 0;
}