unsigned Hash(KeyType K) { // 一个简单的哈希函数(m为全局变量) /********** Begin **********/ /********** End **********/ } void collision(int &p,int d) // 线性探测再散列 { // 开放定址法处理冲突 /********** Begin **********/ /********** End **********/ } int SearchHash(HashTable H,KeyType K,int &p,int &c) { // 在开放定址哈希表H中查找关键码为K的元素，若查找成功，以p指示待查数据 // 元素在表中位置，并返回SUCCESS；否则，以p指示插入位置，并返回UNSUCCESS // c用以计冲突次数，其初值置零，供建表插入时参考。 /********** Begin **********/ /********** End **********/ } int InsertHash(HashTable &H,ElemType e) { // 查找不成功时插入数据元素e到开放定址哈希表H中，并返回OK； // 若冲突次数过大，则重建哈希表，算法9.18 /********** Begin **********/ /********** End **********/ } void TraverseHash(HashTable H,void(*Vi)(int)) { // 按哈希地址的顺序遍历哈希表 printf("哈希地址0～%d\n",H.sizeindex-1); for(int i=0;i<H.sizeindex;i++) // if(H.elem[i].key!=NULL_KEY) // 有数据 Vi(i); printf("\n"); for(int i=0;i<H.sizeindex;i++) // if(H.elem[i].key!=NULL_KEY) // 有数据 Vi(H.elem[i].key); printf("\n"); }补全代码

好的，请看下面的代码：

#define MAXSIZE 100 // 哈希表的最大长度
#define OK 1 // 操作成功
#define ERROR 0 // 操作失败
#define NULLKEY -32768 // 哈希表单元为空的特殊标志

typedef int KeyType;
typedef struct {
    KeyType key; // 关键字
    int count; // 记录查找不成功次数
}ElemType;

typedef struct {
    ElemType *elem; // 数据元素的基址，动态分配数组
    int sizeindex; // 当前哈希表的长度
    int count; // 当前哈希表中的元素个数
}HashTable;

int m; // 全局变量，表示哈希函数表长

// 初始化哈希表
void InitHashTable(HashTable &H) {
    H.elem = new ElemType[MAXSIZE];
    H.sizeindex = MAXSIZE;
    H.count = 0;
    for(int i = 0; i < H.sizeindex; i++) {
        H.elem[i].key = NULLKEY;
        H.elem[i].count = 0;
    }
}

// 哈希函数
unsigned Hash(KeyType K) {
    return K % m;
}

// 线性探测再散列
void collision(int &p, int d) {
    p = (p + d) % MAXSIZE;
}

// 查找关键字
int SearchHash(HashTable H, KeyType K, int &p, int &c) {
    p = Hash(K);
    c = 0;
    while(H.elem[p].key != NULLKEY && H.elem[p].key != K) {
        c++;
        collision(p, c);
    }
    if(H.elem[p].key == K) {
        return OK;
    } else {
        return ERROR;
    }
}

// 插入关键字
int InsertHash(HashTable &H, ElemType e) {
    int p, c;
    if(SearchHash(H, e.key, p, c)) {
        return ERROR; // 关键字已经存在
    } else if(c < MAXSIZE / 2) {
        H.elem[p] = e; // 插入关键字
        H.count++;
        return OK;
    } else {
        // 重建哈希表
        ElemType *temp = H.elem;
        int tempindex = H.sizeindex;
        H.sizeindex = 2 * H.sizeindex;
        H.elem = new ElemType[H.sizeindex];
        H.count = 0;
        for(int i = 0; i < H.sizeindex; i++) {
            H.elem[i].key = NULLKEY;
            H.elem[i].count = 0;
        }
        for(int i = 0; i < tempindex; i++) {
            if(temp[i].key != NULLKEY) {
                InsertHash(H, temp[i]);
            }
        }
        InsertHash(H, e);
        delete []temp;
        return OK;
    }
}

// 遍历哈希表
void TraverseHash(HashTable H, void(*Vi)(int)) {
    printf("哈希地址0～%d\n", H.sizeindex-1);
    for(int i = 0; i < H.sizeindex; i++) {
        Vi(i);
    }
    printf("\n");
    for(int i = 0; i < H.sizeindex; i++) {
        Vi(H.elem[i].key);
    }
    printf("\n");
}

此代码实现了一个开放定址哈希表，其中包括了哈希表的初始化、哈希函数、线性探测再散列、查找关键字、插入关键字和遍历哈希表等操作。在插入关键字时，若冲突次数过大，则重建哈希表，并将已有的数据重新插入新的哈希表中。在遍历哈希表时，按哈希地址的顺序遍历哈希表，并输出关键字。