迅雷面试题目

题目：现在需要有一个存放整数的hash表，hash表存储单位称为桶，每一个桶最多可以存放3个整数，当一个桶中可以存放的元素超过三个元素时，则需要将新的元素放入溢出桶中，每个溢出桶最多也可以放3个元素，多个溢出桶使用链表串联起来。Hash桶的基本桶个数为素数P，hash函数对P取模。代码定义如下：

#define P 7
#define Bucket_Size 3
#define NULL_DATA -1
struct bucket_node
{
    int data[Bucket_Size];
    struct bucket_node* next;
};
bucket_node hash_table[P];

请你完成init_bucket_node()函数，成功存储的时候函数返回1
代码如下所示：

void init_bucket_node()
{
    for (int i = 0; i < P; ++i)
    {
        for (int j = 0; j < Bucket_Size; ++j)
        {
            hash_table[i].data[j] = NULL_DATA;
        }
        hash_table[i].next = NULL;
    }
}
int Hash(int key)
{
    return key % P;
}
int insert_new_element(int new_element)
{
    //将关键值和地址进行对应
    int bucket = Hash(new_element);
    int i = 0;
    //不断的插入
    for (int i = 0; i < Bucket_Size; ++i)
    {
        if (hash_table[bucket].data[i] == NULL_DATA)
        {
            hash_table[bucket].data[i] = new_element;
            return true;
        }
    }
    // 当前桶结点如果满了话，看下一个是否存在，然后插入。如果下一个桶结点也满了，就申请新的结点。
    bucket_node* p = &hash_table[bucket];
    while (p->next != NULL)
    {
        //继续查找结点
        for (int i = 0; i < Bucket_Size; ++i)
        {
            if (p->next->data[i] == NULL_DATA)
            {
                p->next->data[i] = new_element;
                return true;
            }
        }
        //继续向下一个桶查找
        p = p->next;
    }
    bucket_node* new_node = new bucket_node;
    for (int i = 0; i < Bucket_Size; ++i)
    {
        new_node->data[i] = NULL_DATA;
    }
    new_node->next = NULL;
    new_node->data[0] = new_element;
    new_node->next = hash_table[bucket].next;
    // 这里也可以写出p->next=new_node;因为p存放的就是hash_table[bucket]的地址。
    hash_table[bucket].next = new_node;
    return true;
}

测试代码如下：

int main()
{
    init_bucket_node();
    int array[] = { 1,8,15,22,29,36,42,16,23,29 };
    for (int i = 0; i < 7; ++i)
    {
        insert_new_element(array[i]);
    }
    
}