leetcode之两数之和：哈希表算法与暴力算法的比较(C语言)

暴力算法：两层遍历循环，第一层找出一个i，第二层找出j，如果i+j=target，则返回；复杂度为O(n^2)。
哈希表算法：先将数组各数及其索引绑定插入哈希表中，从循环遍历数组nums[i]，看target-nums[i]是否在哈希表中，如果哈希表中存在nums[j]==target-nums[i]，则nums[i]+nums[j]==target，返回(i,j)；遍历数组的复杂度为O(n)，从哈希表中查找元素的复杂度为O(1)，则总复杂度为O(n)*O(1)=O(n)。

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

//结点定义
typedef struct Node
{
    int index;
    int num;
    struct Node *next;
}Node;
//哈希表定义
typedef struct HashTable
{
    Node **B;   //Node结点的指针数组，存储Node结点的指针
    int len;    //数组长度
}HashTable;

void Init_HT(HashTable *ht,int n);
void Free_HT(HashTable *ht);
void Insert_Item_HT(HashTable *ht,int index,int num);
int Search_Item_HT(HashTable *ht,int num);
int *twosum(int *nums,int n,int target,int *returnSize);    //哈希表算法：复杂度O(n)
int *twosums(int *nums,int n,int target,int *returnSizes);  //暴力算法：复杂度O(n^2)
int main()
{
    int *nums;
    int n;
    printf("输入数组数量：");
    scanf("%d",&n);

    nums=(int *)malloc(sizeof(int)*n);

    //利用随机函数生成数组
    int i;
    for(i=0;i<n;i++)
        nums[i]=rand()+i;

    int target,*returnSize,*returnSizes;
    returnSize=(int *)malloc(sizeof(int));
    returnSizes=(int *)malloc(sizeof(int));

    target=nums[i-1]+nums[i-2];

    printf("\n哈希表算法：\n");
    int *result;
    DWORD t1,t2;
    t1=GetTickCount();
    result=twosum(nums,n,target,returnSize);
    t2=GetTickCount();

    if(*returnSize==2)
        printf("nums[%d]:%d + nums[%d]:%d = %d\nt1:%d t2:%d \ntimeconsuming:%d\n",result[0],nums[result[0]],result[1],nums[result[1]],target,t1,t2,t2-t1);
    else
        printf("无！");

    printf("\n暴力算法：\n");
    int *result2;
    DWORD t3,t4;
    t3=GetTickCount();
    result2=twosums(nums,n,target,returnSizes);
    t4=GetTickCount();

    if(*returnSizes==2)
        printf("nums[%d]:%d + nums[%d]:%d = %d\n t3:%d t4:%d \ntimeconsuming:%d\n",result2[0],nums[result2[0]],result2[1],nums[result2[1]],target,t3,t4,t4-t3);
    else
        printf("无！");
    return 0;
}
//暴力算法：复杂度O(n^2)
int *twosums(int *nums,int n,int target,int *returnSizes)
{
    int i,j,*k;
    k=(int *)malloc(sizeof(int)*2);

    for(i=0;i<n-1;i++)
        for(j=i+1;j<n;j++)
        {
            if(nums[i]+nums[j]==target)
            {
                k[0]=i;
                k[1]=j;
                *returnSizes=2;
                return k;
            }
        }
    *returnSizes=0;
    return NULL;
}
//哈希表算法：复杂度O(n)
int *twosum(int *nums,int n,int target,int *returnSize)
{
    int i,*j;
    j=(int *)malloc(sizeof(int)*2);

    HashTable *ht;
    ht=(HashTable *)malloc(sizeof(HashTable));

    Init_HT(ht,n);
    for(i=0;i<n;i++)
        Insert_Item_HT(ht,i,nums[i]);

    for(i=0;i<n;i++)
    {
        int k;
        k=Search_Item_HT(ht,target-nums[i]);

        if(k>=0 && k!=i)
        {
            j[0]=i;
            j[1]=k;
            *returnSize=2;
            return j;
        }
    }
    *returnSize=0;
    return NULL;
}
//哈希表初始化
void Init_HT(HashTable *ht,int n)
{
    ht->len=n;
    ht->B=(Node **)malloc(sizeof(Node *)*n);

    int i;
    for(i=0;i<n;i++)
        ht->B[i]=NULL;
}
//释放哈希表
void Free_HT(HashTable *ht)
{
    int i;
    for(i=0;i<ht->len;i++)
    {
        Node *cur,*pre;
        cur=(Node *)malloc(sizeof(Node));
        pre=(Node *)malloc(sizeof(Node));

        cur=ht->B[i];

        while(cur)
        {
            pre=cur;
            cur=cur->next;
            free(pre);
        }
    }
    free(ht);
}
//向哈希表插入元素
void Insert_Item_HT(HashTable *ht,int index,int num)
{
    int i;
    i=num%ht->len;

    Node *p;
    p=(Node *)malloc(sizeof(Node));
    p->index=index;
    p->num=num;

    if(ht->B[i])
    {
        p->next=ht->B[i]->next;
        ht->B[i]->next=p;
    }
    else
    {
        ht->B[i]=p;
        p->next=NULL;
    }
}
//从哈希表中查找元素
int Search_Item_HT(HashTable *ht,int num)
{
    int i;
    i=num%ht->len;

    Node *p;
    p=(Node *)malloc(sizeof(Node));
    p=ht->B[i];

    while(p)
    {
        if(p->num==num)
            return p->index;
        else
            p=p->next;
    }
    return -1;
}