迅雷面试哈希表

#if 1
//现在有一个用来存放整数的Hash表，Hash表的存储单位称为桶，每个桶能放3个整数，
//此Hash表的基桶数目为素数P，Hash表的hash函数对P取模。代码定义如下：
//当一个桶中要放的元素超过3个时，则要将新的元素存放在溢出桶中，
//每个溢出桶也能放3个元素，多个溢出桶使用链表串起来。

#define P 7
#define NULL_DATA -1
#define BUCKET_NODE_SIZE 3
struct bucket_node
{
	int data[BUCKET_NODE_SIZE];
	struct bucket_node *next;
};
bucket_node hash_table[P];
//现在假设hash_table已经初始化好了，insert_new_element()函数目的是
//把一个新的值插入hash_table中，元素插入成功时，函数返回0，否则返回-1，完成函数。
int Hash(int key)
{
	return key%P;
}

void Init_bucket_node()
{
	for (int i = 0; i < P; ++i)
	{
		for (int j = 0; j < BUCKET_NODE_SIZE; j++)
		{
			hash_table[i].data[j] = NULL_DATA;
			hash_table[i].next = NULL;

		}
	}
}
int Insert_new_element(int new_element)
{
	int index = Hash(new_element);
	for (int i = 0; i < BUCKET_NODE_SIZE; ++i)
	{
		if (hash_table[index].data[i] == NULL_DATA)
		{
			hash_table[index].data[i] = new_element;
			return 0;
		}
	}
	bucket_node*p = &hash_table[index];
	while (p->next != NULL)
	{
		p = p->next;//找下一个溢出桶
		for (int i = 0; i < BUCKET_NODE_SIZE; ++i)
		{
			if (p->data[i] == NULL_DATA)
			{
				p->data[i] = new_element;
				return 0;
			}
		
		}  
	}
	//创建新溢出桶
	bucket_node*s = (bucket_node*)malloc(sizeof(bucket_node));
	for (int i = 0; i < BUCKET_NODE_SIZE; ++i)
	{
		s->data[i] = NULL_DATA;
	}
	s->next = NULL;
	s->data[0] = new_element;
	p->next = s;
	return 0;
}

int main()
{  
	Init_bucket_node();
	int array[] =     { 15,14,21,87,96,293,35,24,149,19,63,16,103,77,5,153,145,356,51,68,705,453 };
	int array[] = { 1,8,15,22,29,36,43};
	for (int i = 0; i < sizeof(array) / sizeof(int); i++)
	{
		Insert_new_element(array[i]);
	}
	return 0;
}
#endif

题目：现在有一个用来存放整数的Hash表，Hash表的存储单位称为桶，每个桶能放3个整数，当一个桶中要放的元素超过3个时，则要将新的元素存放在溢出桶中，每个溢出桶也能放3个元素，多个溢出桶使用链表串起来。此Hash表的基桶数目为素数P，Hash表的hash函数对P取模。代码定义如下：现在假设hash_table已经初始化好了，insert_new_element()函数目的是
把一个新的值插入hash_table中，元素插入成功时，函数返回0，否则返回-1，完成函数。