用c语言写一个题目，题目描述 定义哈希函数为H(key) = key%11，输入表长（大于、等于11）。输入关键字集合，用线性探测再散列构建哈希表，并查找给定关键字。输入 测试次数t 每组测试数据为： 哈希表长m、关键字个数n n个关键字 查找次数k k个待查关键字 输出 对每组测试数据，输出以下信息： 构造的哈希表信息，数组中没有关键字的位置输出NULL 对k个待查关键字，分别输出：0或1（0—不成功，1—成功）、比较次数、查找成功的位置（从1开始）

以下是基于题目描述的C语言代码实现，其中用到了线性探测再散列解决哈希冲突的问题：

#include <stdio.h>
#include <stdlib.h>

#define NULLKEY -32768  // 哈希表中无关键字时的标记
#define SUCCESS 1
#define UNSUCCESS 0

typedef int Status;  // 状态类型：SUCCESS 或 UNSUCCESS
typedef int KeyType;  // 关键字类型
typedef struct {
    KeyType key;
} ElemType;  // 数据元素类型
typedef struct {
    ElemType *elem;  // 数据元素存储基址，动态分配数组
    int count;  // 当前数据元素个数
    int size;  // 当前分配的存储容量
} HashTable;  // 哈希表类型

int m;  // 哈希表长
int n;  // 关键字个数
int k;  // 待查关键字个数
int *search_keys;  // 待查关键字数组
int total_cmp = 0;  // 总比较次数

// 初始化哈希表
Status InitHashTable(HashTable *H) {
    int i;
    H->elem = (ElemType *)malloc(m * sizeof(ElemType));
    if (!H->elem) {
        return UNSUCCESS;
    }
    for (i = 0; i < m; i++) {
        H->elem[i].key = NULLKEY;  // 初始化为空
    }
    H->count = 0;
    H->size = m;
    return SUCCESS;
}

// 哈希函数
int Hash(KeyType key) {
    return key % 11;
}

// 线性探测再散列
int Collision(int *p) {
    int i = 1;  // 线性探测步长
    int c = 0;  // 冲突次数
    while (*p != NULLKEY) {
        c++;
        *p = (*p + i) % m;  // 线性探测
        total_cmp++;
        if (c == m) {  // 冲突次数达到哈希表长时，无法再探测，返回错误
            return UNSUCCESS;
        }
    }
    return SUCCESS;
}

// 插入关键字
Status InsertHash(HashTable *H, KeyType key) {
    int addr = Hash(key);  // 计算哈希地址
    if (H->elem[addr].key == NULLKEY) {  // 若地址空，直接插入
        H->elem[addr].key = key;
        H->count++;
        return SUCCESS;
    } else {  // 否则进行线性探测再散列
        return Collision(&H->elem[addr].key);
    }
}

// 查找关键字的位置
int SearchHash(HashTable H, KeyType key) {
    int addr = Hash(key);  // 计算哈希地址
    int i = 0;  // 冲突次数
    while (H.elem[addr].key != key) {
        i++;
        addr = (addr + 1) % m;  // 线性探测
        total_cmp++;
        if (H.elem[addr].key == NULLKEY || i == m) {  // 未找到或冲突次数达到哈希表长
            return -1;
        }
    }
    return addr;
}

// 输出哈希表信息
void PrintHashTable(HashTable H) {
    int i;
    for (i = 0; i < H.size; i++) {
        if (H.elem[i].key == NULLKEY) {
            printf("NULL ");
        } else {
            printf("%d ", H.elem[i].key);
        }
    }
    printf("\n");
}

int main() {
    int i, j;
    HashTable H;
    printf("请输入测试次数t：");
    scanf("%d", &i);
    while (i--) {
        total_cmp = 0;
        printf("请输入哈希表长m和关键字个数n：");
        scanf("%d %d", &m, &n);
        InitHashTable(&H);
        printf("请输入%d个关键字：", n);
        for (j = 0; j < n; j++) {
            KeyType key;
            scanf("%d", &key);
            InsertHash(&H, key);
        }
        printf("构造的哈希表信息：");
        PrintHashTable(H);
        printf("请输入待查关键字个数k：");
        scanf("%d", &k);
        search_keys = (int *)malloc(k * sizeof(int));
        printf("请输入%d个待查关键字：", k);
        for (j = 0; j < k; j++) {
            scanf("%d", &search_keys[j]);
        }
        for (j = 0; j < k; j++) {
            int addr = SearchHash(H, search_keys[j]);
            if (addr == -1) {
                printf("0 ");
            } else {
                printf("1 ");
                printf("%d ", total_cmp);
                printf("%d ", addr + 1);
            }
        }
        printf("\n");
        free(search_keys);
        free(H.elem);
    }
    return 0;
}

注意：该代码实现中，哈希表的大小需要在运行时动态输入，而不是在编译时固定。此外，程序中对于哈希冲突的处理方式采用了线性探测再散列方法，而其他解决哈希冲突的方法（如拉链法）的实现方式可能有所不同。