关于hash的一个面试题

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

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

    for(int i = 0; i < sizeof(array)/sizeof(int); i++)

    {

        Insert_new_element(array[i]);

    }

    return 0;
}

其完整代码实现如下：

#include <iostream>
#include <malloc.h>
#include <assert.h>
using namespace std;

#define P 7     //hash桶节点的数量，一般取20以内的质数，为了将数据均匀散列
#define BUCKET_NODE_SIZE  3  //每个桶可以存放的元素个数
#define NULL_DATA   -1       //桶均初始化为此

//桶节点的定义
struct bucket_node
{
    int data[BUCKET_NODE_SIZE];   //桶节点数据
    struct bucket_node *next;     //桶节点指针
};

bucket_node hash_table[P];    //定义P个桶


//初始化每个桶节点内的所有data
void Init_Hash_Table(bucket_node (&hash)[P])
{
    for(int i = 0; i < P; ++i){
        for(int j = 0; j < BUCKET_NODE_SIZE; ++j){
            hash[i].data[j] = NULL_DATA;
        }
        hash[i].next = NULL;   //初始化每个hash桶节点的溢出桶为NULL
    }
}

//hash算法
int Hash(int key)
{
    return key % P;    //除留余数法，将key散列至相应的桶
}

//插入函数
void Insert_New_Element(int x)
{
    int index = Hash(x);

    //查看hash桶节点是否填充满元素，若没有将新元素插入空节点位置
    for(int i = 0; i < BUCKET_NODE_SIZE; ++i){
        if(hash_table[index].data[i] == NULL_DATA){
            hash_table[index].data[i] = x;
            return ;
        }
    }

    //hash桶填充满了，查看其是否有溢出桶并检查其溢出桶是否也已经填充满元素
    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] = x;
                return ;
            }
        }
    }

    //hash桶填充满了，并且没有溢出桶，则创建一个溢出桶
    bucket_node *s = (bucket_node*)malloc(sizeof(bucket_node));
    assert(s != NULL);
    //初始化溢出桶的各个节点
    for(int i = 0; i < BUCKET_NODE_SIZE; ++i){
        s->data[i] = NULL_DATA;
    }
    s->next = NULL;
    p->next = s; 
    s->data[0] = x;   //创建溢出桶后将元素插入
}


//测试
int main()
{
    int ar[] = {15,14,21,87,96,293,35,24,149,19,63,16,103,77,5,153,145,356,51,68,705,453 }; 

    int n = sizeof(ar) / sizeof(int);

    Init_Hash_Table(hash_table);
    for(int i = 0; i < n; ++i){
        Insert_New_Element(ar[i]);
    }

    return 0;
}