用C语言（1）自动生成包含数十、数百、数千正整数的若干集合，作为构建不同规模查找表的基础； （2）根据（1）中生成的正整数集合构造散列表，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用开放地址法处理冲突，测量不同规模散列表的查找平均查找长度； （3）基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用链地址法处理冲突，采用控制变量的原理设计实验并观测实验结果，探明散列表的长度m、散列函数的除数p,散列表的装填因子对散列函数平均查找长度的影响规律，形成结论。

这是一个比较复杂的编程和算法问题，需要一定的时间和专业知识才能完成。以下是一个可能的解决方案：

1. 生成正整数集合

可以使用C语言的随机数生成器函数来生成指定数量的正整数集合，例如：

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

#define MAX_NUM 10000

int main()
{
    int n = 100; // 生成100个正整数
    int set[MAX_NUM];
    int i;

    srand(time(NULL)); // 设置随机数种子

    for (i = 0; i < n; i++) {
        set[i] = rand() % MAX_NUM + 1; // 生成1~MAX_NUM之间的随机数
        printf("%d ", set[i]);
    }

    return 0;
}

2. 构造散列表

采用除留余数法作为散列函数，可以先定义一个散列表结构体：

#define MAX_TABLE_SIZE 1000

typedef struct {
    int key;
    int value;
} HashEntry;

typedef struct {
    HashEntry entries[MAX_TABLE_SIZE];
    int size;
} HashTable;

然后可以实现插入和查找操作：

int hash(int key, int p)
{
    return key % p;
}

int insert(HashTable *table, int key, int value, int p)
{
    int index = hash(key, p);

    while (table->entries[index].key != 0) {
        index = (index + 1) % MAX_TABLE_SIZE; // 开放地址法处理冲突
    }

    table->entries[index].key = key;
    table->entries[index].value = value;
    table->size++;

    return index;
}

int search(HashTable *table, int key, int p)
{
    int index = hash(key, p);

    while (table->entries[index].key != key) {
        if (table->entries[index].key == 0) {
            return -1; // 没找到
        }
        index = (index + 1) % MAX_TABLE_SIZE;
    }

    return table->entries[index].value;
}

3. 测量不同规模散列表的查找平均查找长度

可以定义一个函数来计算散列表的平均查找长度：

float calculate_average_search_length(HashTable *table, int p)
{
    int i, j, k;
    int total_len = 0;
    int count = 0;

    for (i = 0; i < MAX_NUM; i++) {
        if (table->entries[i].key != 0) {
            j = i;
            k = 1;
            while (table->entries[j].key != 0) {
                if (k > MAX_NUM) {
                    printf("ERROR: too many iterations\n");
                    return -1;
                }
                j = (j + 1) % MAX_TABLE_SIZE;
                k++;
            }
            total_len += k;
            count++;
        }
    }

    return (float)total_len / count;
}

然后就可以在主函数中生成不同规模的正整数集合，构造散列表，并计算平均查找长度：

int main()
{
    int n = 100; // 生成100个正整数
    int set[MAX_NUM];
    int i;

    srand(time(NULL)); // 设置随机数种子

    for (i = 0; i < n; i++) {
        set[i] = rand() % MAX_NUM + 1; // 生成1~MAX_NUM之间的随机数
    }

    HashTable table;
    table.size = 0;

    // 构造散列表
    for (i = 0; i < n; i++) {
        insert(&table, set[i], i, 7); // p=7
    }

    // 计算平均查找长度
    float len = calculate_average_search_length(&table, 7);
    printf("Average search length: %.2f\n", len);

    return 0;
}

4. 探明散列表的长度m、散列函数的除数p,散列表的装填因子对散列函数平均查找长度的影响规律

可以通过多次运行上述程序，分别使用不同的散列函数除数和不同的正整数集合规模，来观察散列表长度、装填因子和平均查找长度之间的关系。例如：

int main()
{
    int n = 1000; // 生成1000个正整数
    int set[MAX_NUM];
    int i;

    srand(time(NULL)); // 设置随机数种子

    for (i = 0; i < n; i++) {
        set[i] = rand() % MAX_NUM + 1; // 生成1~MAX_NUM之间的随机数
    }

    HashTable table;
    table.size = 0;

    // 构造散列表
    for (i = 0; i < n; i++) {
        insert(&table, set[i], i, 31); // p=31
    }

    // 计算平均查找长度
    float len = calculate_average_search_length(&table, 31);
    printf("n=%d, p=%d, m=%d, alpha=%.2f, average search length: %.2f\n", n, 31, MAX_TABLE_SIZE, (float)n / MAX_TABLE_SIZE, len);

    return 0;
}

可以通过多次运行并记录结果，分析不同参数对平均查找长度的影响规律。