假设有两个集合 a 和 b，分别用两个顺序表 la 和 lb表示，即顺序表中的数据元素即为集合中的元素，利用顺序表的基本运算编写一个算法实现集合的交运算，即求一个新的集合c = a∩b。

### 回答1：
算法步骤：

1. 定义一个新的顺序表 lc，用于存储交集元素。

2. 遍历顺序表 la，对于每个元素，判断是否也在顺序表 lb 中出现。

3. 如果出现，则将该元素添加到顺序表 lc 中。

4. 最后返回顺序表 lc，即为集合的交集。

算法实现：

def intersection(la, lb):
    lc = []
    for x in la:
        if x in lb:
            lc.append(x)
    return lc

注意：以上算法实现中，顺序表 la 和 lb 中的元素应为可比较的类型，否则需要自定义比较函数。

### 回答2：
集合的交运算是指对于两个集合中都包含的元素，将它们取出来组成一个新的集合。在这个问题中，我们已经分别用两个顺序表 la 和 lb 来表示了两个集合 a 和 b。现在需要编写一个算法实现集合的交运算，即求一个新的集合 c = a∩b。

我们可以先定义一个新的顺序表 lc，用于存储交集中的元素。然后利用两个顺序表的基本运算，比如遍历、查找、插入、删除等，依次把两个集合中相同的元素插入到 lc 中。

具体的实现步骤如下：

1. 定义一个新的顺序表 lc，用于存储交集中的元素；

2. 遍历集合 a 中的每一个元素，对于每一个元素，都查找它是否在集合 b 中存在，如果存在，则将该元素插入到 lc 中；

3. 遍历集合 b 中的每一个元素，对于每一个元素，都查找它是否在集合 a 中存在，如果存在，则将该元素插入到 lc 中；

4. 返回顺序表 lc，即为新的交集。

下面是一个示例代码，实现了以上步骤：

def intersection(la, lb):
    lc = []
    for i in la:
        if i in lb and i not in lc:
            lc.append(i)
    for j in lb:
        if j in la and j not in lc:
            lc.append(j)
    return lc

在以上代码中，我们定义了一个函数 intersection，它接受两个顺序表 la 和 lb 作为参数。函数首先定义了一个新的顺序表 lc，然后遍历 la 中的每一个元素，如果该元素在 lb 中存在且不在 lc 中，则将其插入到 lc 中；接着遍历 lb 中的每一个元素，如果该元素在 la 中存在且不在 lc 中，则将其插入到 lc 中；最后返回顺序表 lc 即为新的交集。

总之，通过以上的代码实现，我们可以很容易地求出两个集合的交集。在实际应用中，如果需要求多个集合的交集，则可以通过依次求两个集合的交集来实现。例如，将多个集合依次求交集，可以用以下的代码来实现：

def intersection_all(sets):
    result = sets[0]
    for i in range(1, len(sets)):
        result = intersection(result, sets[i])
    return result

在以上代码中，我们定义了一个函数 intersection_all，它接受一个集合列表 sets 作为参数。函数首先将列表中的第一个集合作为起始值 result，然后依次遍历列表中的每个集合，用前面的交集结果 result 来依次求出每两个集合之间的交集，最后得到所有集合的交集。

### 回答3：
集合是数学中的一个重要概念，而集合的交运算是求两个集合中公共的元素。我们可以利用顺序表的基本运算来实现集合的交运算，具体实现如下：

1. 定义两个顺序表la和lb分别表示集合a和集合b，同时定义一个新的顺序表c表示集合a和b的交集。

2. 遍历集合a中的所有元素，对于每个元素，判断其是否同时存在于集合b中。

3. 如果一个元素同时存在于集合b中，那么就将它加入集合c中，否则就跳过它。

4. 遍历完集合a中的所有元素后，集合c就是集合a和b的交集了。

具体的算法实现如下（Python语言）：

def intersect(la, lb):
    # 初始化新的集合c，为空列表
    c = []
    # 遍历集合a中的所有元素
    for a in la:
        # 判断元素a是否也出现在集合b中
        if a in lb:
            # 如果同时存在，就将元素加入集合c中
            c.append(a)
    # 返回集合c作为集合a和b的交集
    return c

以上算法在时间复杂度上是O(m*n)，其中m和n分别是集合a和b的元素个数。如果集合a和b已经排好序，我们可以使用双指针法来简化算法，在时间复杂度上降至O(m+n)：

def intersect(la, lb):
    # 初始化新的集合c，为空列表
    c = []
    # 定义两个指针i和j，分别指向集合a和b的第一个元素
    i, j = 0, 0
    # 只要还有元素待处理，就继续进行循环
    while i < len(la) and j < len(lb):
        # 如果集合a和b中的当前元素相等，就将它加入集合c中，并同时移动两个指针
        if la[i] == lb[j]:
            c.append(la[i])
            i += 1
            j += 1
        # 如果集合a中的当前元素小于集合b中的当前元素，就移动指针i，反之移动指针j
        elif la[i] < lb[j]:
            i += 1
        else:
            j += 1
    # 最后返回集合c作为集合a和b的交集
    return c

以上就是利用顺序表的基本运算实现集合交运算的算法。需要注意的是，该算法只适用于不包含重复元素的集合，如果集合中存在重复元素，则需要进行额外的处理。