LeetCode1

 

1. 两数之和

思路如下

假入给定数组里边最大数是19，而且都是正数，我们可以再写一个数组，弄一个如下的对应关系。不妨假设上边数组叫a数组，下边数组叫b数组。b存储数据的位置是a的值对应的位置，b的值是a的位置。例如，a[1]=7,所以，在b【7】中存1.

经过上方的对应关系，得出以下结果

 

如果我给b数组都在没有数值的地方都赋值为-1,

 

那么在b数组中，就可以很方便找到，a中的某个数m是否存在，如果存在，这个数在b数组相应位置的值，就是m的位置。例如，a中的11存在不，我只需要在b中看b【11】是否等于-1，如果等于-1，那就不存在，不等于就存在，而且11的位置在a中是2，即

a【2】==11。如果我要看，a中12存在不，就在b中看b【12】是不是等于-1，我们一看，b[12]=-1，所以a中不存在这个数。

 

接下来我们回到这个题上，对于这组测试用例，target=9。

我们就可以遍历a数组，从头到尾找那个可以配对的数，看对于，a【i】来说，我需要知道9-a[i]在a中存不存在。那么我们只需要看b【9-a[i]】是不是等于-1，如果不等于，那么这两个数的位置我们就找到了，一个是i，另一个是b【9-a[i]】。

在这个测试用例中，当我们遍历到a[0]时，我们需要知道9-a[0]=9-2=7，也就是7这个值是否存在，我们看b数组，发现b【7】不是-1，所以我们就找到了这两个值，一个是0，一个是b[7]的值，1。

接下来我么分析一下时间。加入a数组有1000个数字，即numsSize=1000，按照你的写法

 

for(i=0; i<numsSize;i++){
    for(j=i+1; j<numsSize; i++){
        .....
    }
}

 

 

这大概算了1000000次。

 

如果按照我这种写法，将a数组中的值对应到b中，运算1000次，遍历a数组，在b中找等不等-1，又运算1000次。总共是2000次。速度是你的500倍。这样写的好处，就是当我知道a[i]了，想要找到他配对的数，就不用在从头到尾找一遍，看看能不能找到那个配对了。你从头到尾找，还不一定能找到，白白浪费了时间。加了b数组之后，一下子就知道配对的存不存在，如果存在，位置也一下子就知道。

 

先假设所有的数都是大于0的，基于以上思想得出以下代码。

 

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

int* twoSum(int* nums, int numsSize, int target){
    int i;
    int *re = (int *)malloc(2*sizeof(int));//用来存结果的
    int b[100];     //    将b全部置位-1

    /**
    *讲一下这个函数
    * void *memset(void *str, int c, size_t n)
    *   第一个参数：str，你要赋值的首地址，
    *   第二个参数：你想要赋的值，只能是一个值。这个值会充满整个地址空间
    *   第三个参数：值所占的字节数，你就写sizeof（类型）
    *
    */
    memset(b, -1, sizeof(int));


    for(i=0; i<numsSize; i++){ //   先做一个对应，以便可以快速找到某个数是否存在
        b[nums[i]] = i;
    }

    for(i=0; i<numsSize; i++){
        if(b[ target-nums[i] ] != -1){//判断另外一个数存不存在
            re[0] = i;
            re[1] = b[ target-nums[i] ];
            break;//找到了另外一个数就退出循环
        }
    }
    return re;
}


//主函数用来测试我的函数

int main()
{
    int a[]={1,2,4,9};
    int *r = twoSum(a, 4, 3);
    printf("%d,%d", r[0], r[1]);
    return 0;
}

 

在判断另外一个数是否存在的代码中

if(b[ target-nums[i] ] != -1){//判断另外一个数存不存在

有一种可能就是target<nums[i] ，这时候就会出现b[负数],这指定是不行的，数组中的索引只能是非负数。方括号里的东西可以叫索引。

从题中来看，因为所有数都是正数，大于target的nums[i]也不可能是解。所以，肯定找不到另外一个数。所以需要加一个条件，target-nums[i]>0 。接下来就出现一个问题，这个条件加在哪里的问题。看这个短路特性（这是个链接），看完你就知道加在哪里了。

 

回头再说说对应的问题。

如果有一个这样的数组{2,2,4}，target = 4；我们在对应的时候，数组中的两个2会对应到一个地方。如下：

b数组中b[2]的值为啥是1而不是0，是因为你是从头到尾遍历a数组从而实现对应的。后边对应的时候讲前边覆盖了。当a[i]=第一个2的时候，另外一个数就是target-a[i]=2。而b[2]正好是第二2。

 

这个题我们做的假设是所有的数都是正数，那如果正数负数都有会怎么样呢。我们说，在a和b对应的时候，是将a的值和位置，互换，然后对应到b中。如果a的值是负数，那不就出现了b[负数]，如下图，

这咋能行，数组的索引不可能是负的啊。

那我们就想一个办法，都把它变成正的。一个很好地办法就是把每一个数都加上一个整数，使得加完之后都是正的。

那加这个正数是多少呢？我也不知道。我们可以找到最小的数，然后加上这个最小的数的绝对值。这样最小的数变成0了。其他的数不就都是正的了。

 

这样，上边那个图就变成了

 

都变成正数了，就可以按照我们一开始的想法往下做了。

 

先把上边思路看懂再看代码

 

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target) {
    int i;
    int *re = (int *)malloc(2*sizeof(int));
    long long b[25536]= {0};//用作对应，类型设为longlong是为了防止数据求和之后范围超出整形表示范围。整形表示范围就是[-25536-25535]
                            // 比如，最小数据为-25536，最大数据是25535.求和之后就会出现25535+25536。
    long long m=nums[0];//m存储最小值，以便将所有的数都变成正数。m为什么也用long long呢，我们是要对m求绝对值的，如果，m=-25536,求绝对值之后就变成了了25536，超过了整型表达范围。
    int top=-1;
    for(i=0; i<numsSize; i++) {
        if(nums[i]<m) {
            m=nums[i];//用来找最小值
        }
        if(2*nums[i]==target) {//这这么写是因为我发现它数据有一个超过了整型表达范围，而我又无法申请那么多空间。你可以不用管。
            re[++top]=i;
        }
    }
    if(top==1) {
        return re;
    }
    m = abs(m);
    for(i=0; i<numsSize; i++) {
        b[nums[i]+m] = i+1;//做对应，由于无法将空间批量赋值为-1，所以就批量赋值为0了，这样，我们保存位置的时候，就不能从0开始，就加一保存。
    }
    for(i=0; i<numsSize; i++) {
            //往下自己看
        if(2*(nums[i]) == target || target+m-nums[i]<= 0) {
            continue;
        }
        if(b[target+m-nums[i]]!=0) {
            re[0] = i;
            re[1] = b[target+m-nums[i]]-1;
            break;
        }
    }
    return re;
}

 

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

int cmp (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

int findb(int* nums, int numsSize,int a){
    int i;
    for(i=0; i<numsSize; i++){
        if(nums[i]==a){
           break;
        }
    }
    return i;
}

int finde(int* nums, int numsSize,int a){
    int i;
    for(i=numsSize-1; i>=0; i--){
        if(nums[i]==a){
           break;
        }
    }
    return i;
}

int* twoSum(int* nums, int numsSize, int target) {
    int *sub = (int *)malloc(numsSize*sizeof(int));
    int i;
    for(i=0; i<numsSize; i++){
        sub[i]=nums[i];
    }
    int *re = (int *)malloc(2*sizeof(int));
    qsort(sub, numsSize, sizeof(int), cmp);
    int end =numsSize-1;
    while(sub[end]+sub[0] > target){
        end--;
    }
    int f, s;
    int e;
    for(i=0; i<end; i++){
        for(e=end; e>i; e--){
            if(sub[i]+sub[e]==target){
                f=sub[i];
                s=sub[e];
                break;
            }
        }
        if(e!=i){
            break;
        }
    }

    re[0]=findb(nums, numsSize,f);
    re[1]=finde(nums, numsSize,s);
    if(re[0]>re[1]){
        int t=re[0];
        re[0]=re[1];
        re[1]=t;
    }
    return re;
}

int main()
{
    int a[]= {-1,-2,-3,-5};
    int *r = twoSum(a, 5, 1-8);
    printf("%d,%d", r[0], r[1]);
    return 0;
}