leetcode two-sum之哈希表解法（C语言）_leetcode two sum hash c语言

简介

leetcode 原题链接：two-sum

• 描述

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

  你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

  示例:

    给定 nums = [2, 7, 11, 15], target = 9
    
    因为 nums[0] + nums[1] = 2 + 7 = 9
    所以返回 [0, 1]

	/**
	 * Note: The returned array must be malloced, assume caller calls free().
	 */
	int* twoSum(int* nums, int numsSize, int target, int* returnSize){
	
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

思路

• 哈希表算法
  创建哈希表，将nums中元素放进哈希表，在哈希表中记录每个数组元素的value和在数组中的
  下标，在将每个nums中元素放进哈希表前，查看哈希表中当前是否已经有和该元素满足相加
  之和等于target的值。
• 示意图

• 流程图
  
• 代码

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

typedef struct t_node
{
	int value;
	int pos;
	struct t_node* next;
}T_NODE;

typedef struct t_hash
{
	T_NODE *head;
}T_HASH;

void hash_free(T_HASH* hash_table, int num)
{
	for (uint32_t i = 0; i < num; i++)
	{
		if (hash_table[i].head)
		{
			T_NODE* node = hash_table[i].head;
			while (node)
			{
				T_NODE* next_node = node->next;
				free(node);
				node = next_node;
			}
		}
	}
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
	T_HASH* hash_table = (T_HASH*)malloc(sizeof(T_HASH)*numsSize);
	if (hash_table == NULL)
	{
		*returnSize = 0;
		return NULL;
	}

	for (uint32_t i = 0; i < numsSize; i++)
	{
		hash_table[i].head = NULL;
	}

	for (uint32_t i = 0; i < numsSize; i++)
	{
		T_NODE* node = (T_NODE*)malloc(sizeof(T_NODE));
		if (node == NULL)
		{
			hash_free(hash_table, numsSize);
			*returnSize = 0;
			return NULL;
		}

		uint32_t mod = abs(nums[i]) % numsSize;
		node->value = nums[i];
		node->pos = i;
		node->next = hash_table[mod].head;
		hash_table[mod].head = node;

		uint32_t expect = abs(target - nums[i]);
		uint32_t expect_mod = expect % numsSize;

		T_NODE* node_temp = hash_table[expect_mod].head;
		while (node_temp)
		{
			if ((node_temp->pos != i) && (node_temp->value + nums[i] == target))
			{
				int* return_nums = (int *)malloc(sizeof(int) * 2);
				if (return_nums == NULL)
				{
					hash_free(hash_table, numsSize);
					*returnSize = 0;
					return NULL;
				}

				return_nums[0] = node_temp->pos;
				return_nums[1] = i;
				*returnSize = 2;
				return return_nums;
			}
			else
			{
				node_temp = node_temp->next;
			}
		}
	}

	*returnSize = 0;
	return NULL;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

• 总结
  该方法以空间换时间，速度很快。