LeetCode01.两数之和（使用哈希表）

第一种方法，使用冒泡排序的思想暴力求解，时间复杂度为O（n^2）
第二种方法，使用哈希表，时间复杂度为O（n）

思路：
假设nums[3,2,4] target=6;
第一步，先在哈希表中查找data=(target-num[0]==3)，如果存在返回对应的索引
第二部，将(mum[0]==3)插入到哈希表中
第三步，在哈希表中查找data=(target-num[1]==4)，如果存在则返回对应的索引，
第四步：将(mum[1]==2)插入到哈希表中
第五步：在哈希表中查找data=(target-num[2]==2)，如果存在则返回对应的索引
…

方法一

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

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

方法二

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
#define NULLKEY -3276

typedef struct HashTable{
	struct Node * pElem;
	int count;
}HT,*PHT;

typedef struct Node{
	int index;
	int data;
}NODE,*PNODE;

void init(PHT pHashTable,int size);
bool insert(PHT pHashTable,int data,int index,int size);
int Hash(int val,int size);
void printHashTable(PHT pHashTable);
int search(PHT pHashTable,int val,int size);
void destory(PHT pHashTable);

//查找失败时返回-1
int search(PHT pHashTable,int val,int size){
	int add=abs(Hash(val,size));
	while(pHashTable->pElem[add].data!=val){
		add=(add+1)%size;
		if(add==abs(Hash(val,size))||pHashTable->pElem[add].data==NULLKEY){
			//printf("查找失败\n");
			return -1;
		}
	}
	return pHashTable->pElem[add].index;
}
//打印哈希表
void printHashTable(PHT pHashTable){
	int i;
	for(i=0;i<pHashTable->count;i++){
		printf("%d\n",pHashTable->pElem[i].data);
	}
}
//哈希函数
int Hash(int data,int size){
	return data%size;
}
//插入
bool insert(PHT pHashTable,int val,int index,int size){
	int add=abs(Hash(val,size));
	while(pHashTable->pElem[add].data!=NULLKEY){
		add=(add+1)%size;
		if(add==abs(Hash(val,size))){
			return false;
		}
	}
	pHashTable->pElem[add].index=index;
	pHashTable->pElem[add].data=val;
	return true;
}
//初始化哈希表
void init(PHT pHashTable,int size){
	//int size = 123;//哈希表的大小为3
	pHashTable->pElem = (PNODE)malloc(sizeof(NODE)*size);
	if(pHashTable->pElem==NULL){
		printf("动态内存申请失败\n");
		exit(-1);
	}
	pHashTable->count=size;
	int i;
	for(i=0;i<size;i++){
		pHashTable->pElem[i].data=NULLKEY;
		pHashTable->pElem[i].index=NULLKEY;
	}
	return;
}
//释放哈希表堆空间
void destory(PHT pHashTable){
	free(pHashTable->pElem);
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    *returnSize=2;
    HT hashTable;//定义一个哈希表
    init(&hashTable,numsSize);
    int i;
    int *a;
    a = (int *)malloc(sizeof(int)*2);
    for(i=0;i<numsSize;i++){
       int data = nums[i];
        int result = search(&hashTable,target-data,numsSize);
        insert(&hashTable,data,i,numsSize);
       
        if(result!=-1){
             a[0]=result;
           a[1] = i;
            destory(&hashTable);
		   return a;
        }
		
         
    }
    return a;
}