1. 自动生成包含数百、数千、数万正整数的若干集合，作为构建不同规模查找表的基础； 2. 基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用线性探测法处理冲突，实现散列查找算法，根据（1）中生成的正整数集合构造散列表，测量不同规模散列表的平均查找长度； 3. 基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用链地址法处理冲突，实现散列查找算法，根据（1）中生成的正整数集合构造散列表，测量不同规模散列表的平均查找长度；并写出相关代码

这是一个比较复杂的问题，需要涉及到数据结构和算法的知识，下面我将分步解释。

1. 生成正整数集合

我们可以使用随机数生成算法来生成包含数百、数千、数万正整数的集合。这里提供一个Python实现的示例：

import random

# 生成包含n个正整数的集合
def generate_set(n):
    s = set()
    while len(s) < n:
        s.add(random.randint(1, 10000))
    return s

# 生成不同规模的集合
set_100 = generate_set(100)
set_1000 = generate_set(1000)
set_10000 = generate_set(10000)

2. 基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用线性探测法处理冲突，实现散列查找算法，根据（1）中生成的正整数集合构造散列表，测量不同规模散列表的平均查找长度；

散列表是一种常用的数据结构，它通过散列函数将数据映射到一个固定大小的数组中，从而实现快速的查找操作。散列函数的作用是将关键字映射到一个固定的位置，以实现常数级别的查找效率。除留余数法是一种常用的散列函数，它可以将任意大小的关键字映射到一个固定范围内的位置。线性探测法是一种处理冲突的方法，它在发生冲突的时候，将关键字插入到散列表中下一个空的位置。如果下一个位置也被占用了，就继续向后探测，直到找到一个空的位置为止。

下面是一个Python实现的散列表，使用除留余数法和线性探测法来处理冲突：

class HashTable:
    def __init__(self, size):
        self.size = size
        self.keys = [None] * size
        self.values = [None] * size

    def __setitem__(self, key, value):
        index = self.hash(key)
        while self.keys[index] is not None and self.keys[index] != key:
            index = (index + 1) % self.size
        self.keys[index] = key
        self.values[index] = value

    def __getitem__(self, key):
        index = self.hash(key)
        while self.keys[index] is not None:
            if self.keys[index] == key:
                return self.values[index]
            index = (index + 1) % self.size
        raise KeyError(str(key))

    def hash(self, key):
        return key % self.size

    def avg_search_length(self):
        total = 0
        count = 0
        for i in range(self.size):
            if self.keys[i] is not None:
                total += self.search_length(i)
                count += 1
        return total / count

    def search_length(self, index):
        current_key = self.keys[index]
        count = 0
        while self.keys[index] is not None and self.keys[index] != current_key:
            count += 1
            index = (index + 1) % self.size
        return count

# 构造散列表
def build_hash_table(s):
    size = len(s)
    h = HashTable(size)
    for key in s:
        h[key] = key
    return h

# 测量平均查找长度
def measure_avg_search_length(s):
    h = build_hash_table(s)
    avg_search_length = h.avg_search_length()
    print(f"集合大小: {len(s)}, 平均查找长度: {avg_search_length}")

# 测试不同规模散列表的平均查找长度
measure_avg_search_length(set_100)
measure_avg_search_length(set_1000)
measure_avg_search_length(set_10000)

3. 基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用链地址法处理冲突，实现散列查找算法，根据（1）中生成的正整数集合构造散列表，测量不同规模散列表的平均查找长度；并写出相关代码

链地址法是另一种处理冲突的方法，它在发生冲突的时候，将关键字插入到一个链表中。这个链表可以是一个简单的Python列表，也可以是一个更复杂的数据结构，如链表或树。

下面是一个Python实现的散列表，使用除留余数法和链地址法来处理冲突：

class ListNode:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.next = None

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [None] * size

    def __setitem__(self, key, value):
        index = self.hash(key)
        node = self.table[index]
        while node is not None:
            if node.key == key:
                node.value = value
                return
            node = node.next
        new_node = ListNode(key, value)
        new_node.next = self.table[index]
        self.table[index] = new_node

    def __getitem__(self, key):
        index = self.hash(key)
        node = self.table[index]
        while node is not None:
            if node.key == key:
                return node.value
            node = node.next
        raise KeyError(str(key))

    def hash(self, key):
        return key % self.size

    def avg_search_length(self):
        total = 0
        count = 0
        for i in range(self.size):
            if self.table[i] is not None:
                total += self.search_length(self.table[i])
                count += 1
        return total / count

    def search_length(self, node):
        count = 0
        while node is not None:
            count += 1
            node = node.next
        return count

# 构造散列表
def build_hash_table(s):
    size = len(s)
    h = HashTable(size)
    for key in s:
        h[key] = key
    return h

# 测量平均查找长度
def measure_avg_search_length(s):
    h = build_hash_table(s)
    avg_search_length = h.avg_search_length()
    print(f"集合大小: {len(s)}, 平均查找长度: {avg_search_length}")

# 测试不同规模散列表的平均查找长度
measure_avg_search_length(set_100)
measure_avg_search_length(set_1000)
measure_avg_search_length(set_10000)