断更了半年，一直忙实习工作。。。。。

回家考驾照了，计划在家 研究android壳/刷leetcode/做毕业设计

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

 

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

用C++的map就可以做，自己实现了一个c的hash表。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include<stdlib.h>
#include <math.h>
using namespace std;

struct Node
{
    int val;
    int index;
    struct Node *Next;
};

void insertTable(int number,struct Node **hashTable,int numSize,int index)
{
    int idx=abs(number)%numSize;
    struct Node * hashTemp=hashTable[idx];
    struct Node *add=(struct Node*)malloc(sizeof(struct Node));
    add->val=number;
    add->index=index;
    add->Next=hashTemp->Next;
    hashTemp->Next=add;

}
int searchTable(struct Node **hashTable,int searchNum,int numSize)
{
    int idx=abs(searchNum)%numSize;
    struct Node *hashTemp=hashTable[idx]->Next;
    while(hashTemp!=NULL)
    {
        if(hashTemp->val==searchNum)
        {
            return hashTemp->index;
        }
        //printf("%d %d\n",hashTemp->val,searchNum);
        hashTemp=hashTemp->Next;
    }
    return -1;
}
struct Node** bulidHashTable(int* num,int numSize)
{
    int i=0;
    struct Node **hashTable=(struct Node**)malloc(numSize*sizeof(struct Node *));
    for(i=0;i<numSize;i++)
    {
        hashTable[i]=(struct Node*)malloc(sizeof(struct Node));
        hashTable[i]->Next=NULL;
    }
    for(i=0;i<numSize;i++)
    {
        insertTable(num[i],hashTable,numSize,i);
    }
    return hashTable;

}
int* searchTarget(struct Node** HashTable,int target,int numSize,int *num)
{
    int ret_idx=-1;
    for(int i=0;i<numSize;i++)
    {
        ret_idx=searchTable(HashTable,target-num[i],numSize);
        if(ret_idx!=-1&&ret_idx!=i)
        {
            int *result = (int*)malloc(sizeof(int) * 2);
            result[0]=i;
            result[1]=ret_idx;
            return result;
        }
    }
    return NULL;
}
void freeHashTable(struct Node** HashTable,int numSize)
{
    struct Node *hashTemp=NULL;
    struct Node *hashDele=NULL;
    for(int i=0;i<numSize;i++)
    {
        hashTemp=HashTable[i];
        while(hashTemp!=NULL)
        {
            hashDele=hashTemp;
            hashTemp=hashTemp->Next;
            free(hashDele);
        }
    }
    free(HashTable);
}
int* twoSum(int* num,int numSize,int target,int* returnSize)
{
    int *result=NULL;
    struct Node** hashTable=bulidHashTable(num,numSize);
    result=searchTarget(hashTable,target,numSize,num);
    if(result!=NULL)
    {
        //printf("%d %d\n",result[0],result[1]);
        *returnSize=2;
        freeHashTable(hashTable,numSize);
        return result;
    }
    freeHashTable(hashTable,numSize);
    return result;
}
int main()
{
    int num[] ={3,2,4};
    int *returnSize=NULL;
    twoSum(num,3,6,returnSize);
    return 0;
}