C语言数据结构与算法每日系列（1）两数之和

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

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

示例:

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

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

方法（1）：暴力法

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

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

int main ()
{
    int nums[4] = {0, 1, 24, 22};
    int numsSize = 4;
    int target = 23;
    int returnSize = 0;
    int *result = NULL;
    result = twoSum(nums, numsSize, target, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("the result is %d\n", result[i]);
    }
}

方法2： Hash法

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

typedef struct hash_data {
    int key; // key
    int value; // value
    hash_data* next; // avoid the hash confilction
} hash_data;

typedef struct hash_table {
    hash_data** head; // the array of hash_table(hash_node* head[MAX_HASH_TABLE_SIZE])
    int hash_width; //the element num of hash_table
}hash_table;

/* init hash_table */
int hash_init(hash_table* table, int width)
{
    if (width < 0) {
        return -1;
    }
    hash_data** tmphash = malloc(sizeof(hash_data*) * width);
    table->head = tmphash;
    memset(table->head, 0, width * sizeof(hash_data*));
    if (table->head == NULL) {
        return -1;
    }
    table->hash_width = width;
    return 0;
}

/* free hash_table */
int hash_free(hash_table table, int width)
{
    if (table.head != NULL) {
        for (int i = 0; i < table.width; i++) {
            hash_data* ele_head = table.head[i];
            while (ele_head != NULL) {
                hash_data* tmp = ele_head;
                ele_head = ele_head->next;
                free(tmp);
            }
        }
        free(table.head);
        table.head = NULL;
    }
    table.width = width;
}

/* the function of hash */
int hash_addr(hash_table table, int key)
{
    int table_index = abs(key) % table.hash_width;
    return table_index;
}

/* insert key-value to hash_table */
int hash_insert(hash_table table, int key, int value)
{
    hash_data* tmpData = malloc(sizeof(hash_data));
    if (tmpData = NULL) {
        return -1;
    }
    tmpData->key = key;
    tmpData->value = value;
    int table_index = hash_addr(table, key);
    tmpData->next = table.head[table_index];
    table.head[table_index] = tmpData;
    return 0;
}

/* select key-value form hash_table */
hash_data* hash_find(hash_table table, int key, int value)
{
    int k = hash_addr(table, key);
    hash_data* ele_head = table.head[k];
    while (ele_head != NULL) {
        if (ele_head->key == key) {
            return ele_head;
        }
        ele_head = ele_head->next；
    }
    return NULL;
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize)
{
    int* res = (int*)malloc(sizeof(int) * 2);
    *returnSize = 0;

    hash_table table;
    hash_init(table);
    for (int i =  0; i < numsSize; i++) {
        hash_insert(table, nums[i], i);
    }

    for (int i = 0; i < numsSize; i++) {
        int value = target - nums[i];
        hash_data* data = hash_find(table, value);
        if (data != NULL && data->value != i) {
            res[1] = i;
            res[0] = data->value;
            *returnSize = 2;
            return res;
        }
    }
    return res;
}

int main ()
{
    int nums[4] = {0, 1, 24, 22};
    int numsSize = 4;
    int target = 23;
    int returnSize = 0;
    int *result = NULL;
    result = twoSum(nums, numsSize, target, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("the result is %d\n", result[i]);
    }
}