1. Two Sum

来源：互联网发布：大班美工剪纸花瓣编辑：程序博客网时间：2024/05/16 07:55

这里写图片描述
第一种暴力求解法，用两个循环，找到这样的数就直接返回，时间复杂度为O（N^2）

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

上面那种方法虽然简单，但是耗时，第二种方法采用Hash存储数据和它的下标，这样空间复杂度为O（N），这样以空间换时间，时间复杂度为O（N），运行时间减少到4ms,完美!

typedef struct HashNode{    int indice;    int value;    struct HashNode *next;}*List;typedef struct Hash{    int size;    List Thelist;}*Hashtable;int NextPrime(int N)//求不小于N的最小素数{    int i;    if(!(N%2))N++;//保证N是奇数    for(;;N=N+2)    {        for(i=(int)sqrt(N);i>2;i--)            if(!(N%i))break;        if(2==i)break;    }    return N;}void Insert(Hashtable H,List L){    int key;    key=(unsigned int)L->value%H->size;//注意输入值有负数，所以key的值可能为负，但是数组下标不能为负，所以要用unsigned int将其转化为正整数    L->next=H->Thelist[key].next;    H->Thelist[key].next=L;}int Search(Hashtable H,int value){    int key;    List p;    key=(unsigned int)value%H->size;    p=H->Thelist[key].next;    while(p)    {        if(value==p->value)            return p->indice;        p=p->next;    }    return 0;}int* twoSum(int* nums, int numsSize, int target) {    int *sum,i,x,y;    Hashtable H;    List temp;    sum=malloc(sizeof(int)*2);    H=malloc(sizeof(struct Hash));    H->size=NextPrime(numsSize);    H->Thelist=malloc(sizeof(struct HashNode)*H->size);    for(i=0;i<H->size;i++)        H->Thelist[i].next=NULL;    for(i=0;i<numsSize;i++)    {        temp=malloc(sizeof(struct HashNode));        temp->value=nums[i];        temp->indice=i;        Insert(H,temp);    }    for(i=0;i<numsSize;i++)    {        x=i;        y=Search(H,target-nums[i]);        if(y&&x!=y)        {            sum[0]=x<y?x:y;            sum[1]=x+y-sum[0];            return sum;        }    }    return sum;}

第三种用c++中的STL中的map，时间复杂度也是O（N），但是程序代码比C语言的简单的多

class Solution {public:    vector<int> twoSum(vector<int>& nums, int target)     {        vector<int>result;        if(nums.size()==0)            return result;        unordered_map<int,int>number;        for(int i=0;i<nums.size();i++)        {            if(number.find(target-nums[i])==number.end())                    number[nums[i]]=i;            else            {                result.push_back(number[target-nums[i]]);                result.push_back(i);                break;            }        }        return result;    }};

第四种方法：双指针法

class Solution {public:    vector<int> twoSum(vector<int>& nums, int target)     {        vector<int>result;        vector<int>temp(nums);        if(nums.size()==0)            return result;        sort(nums.begin(),nums.end());        int i=0;        int j=nums.size()-1;        int sum;        while(i<j)        {            sum=nums[i]+nums[j];            if(sum==target)            {                for(int k=0;k<temp.size();k++)                {                    if(temp[k]==nums[i]||temp[k]==nums[j])                        result.push_back(k);                }                return result;            }            else if(sum<target)                i++;            else                j--;        }        return result;    }};

0 0