1323: 算法2-1：集合union

题目链接请点击

题目描述

假设利用两个线性表LA和LB分别表示两个集合A和B（即：线性表中的数据元素即为集合中的成员），现要求一个新的集合A=A∪B。这就要求对线性表做如下操作：扩大线性表LA，将存在于线性表LB中而不存在于线性表LA中的数据元素插入到线性表LA中去。只要从线性表LB中依次取得每个元素，并依值在线性表LA中进行查访，若不存在，则插入之。上述操作过程可用下列算法描述之。

图：将两个列表合并的算法（C/C++描述）
上图算法中，在第8行取得集合B中的元素，然后再在第10行插入到集合A中。你的任务是先输出集合A和集合B中的元素，每个集合在一行中输出。然后每次在将集合B中的元素取出插入到集合A尾部后输出集合A中的元素。当然你的代码可以和上面的代码不一样，只要有相同的输出即可。

输入

有多组测试数据，每组测试数据占两行。第一行是集合A，第一个整数m（0

输出

每组测试数据输出n+2行：前两行分别输出集合A、集合B中的数据，后面n行是每次从B中取出元素插入到A尾部后的集合A。每行整数之间用一个空格隔开，每组测试数据之间用一行空行隔开。

样例输入

5 1 5 2 6 3
3 1 7 9
1 3
2 2 7
4 2 5 1 4
4 1 2 4 5

样例输出

1 5 2 6 3
1 7 9
1 5 2 6 3
1 5 2 6 3 7
1 5 2 6 3 7 9

3
2 7
3 2
3 2 7

2 5 1 4
1 2 4 5
2 5 1 4
2 5 1 4
2 5 1 4
2 5 1 4

提示：

1、使用数组时，给集合 A 分配的空间不小于200。因为将 B 中的元素添加到 A 中时，可能会超过 100 了。

2、利用 scanf(“%d”,&m) != EOF 来判断是否还有输入数据。

3、一个细节问题就是题目要求输出的格式是每行中元素之间用一个空格隔开，每组输出间用一个空行隔开。也就是说4个元素间只有3个空格，2组输出间只有1个空行。处理方法都一样。两种方法：一是除了第一个元素，后面的每个元素之前输出个空格；二是除了最后一个元素，前面的每个元素之后都输出一个空格。我往往采用第一种方式，因为许多编程语言中的数组都是从0开始的，而0正是判断语句中的“假”（当然Java中不是这样的）。

总结：

本题考查的是线性表的基本操作。实际上只考察了遍历和添加操作。虽然算法中使用的是“插入”，然而本题只要求插入到链表的尾部，因而只是添加而已。线性表按存储结构分为顺序表和链表。顺序表在插入时往往需要移动某些元素，而移动元素需要消耗大量时间。如果插入操作次数很多的话，采用链表会好些。但由于只是插入到线性表的尾部，因而也不必移动元素。所以采用顺序表解本题也不失为一个好方法。

如果采用顺序表，事先需要分配足够的内存。题目中 m 和 n 都是不大于100的，是不是给两个顺序表（数组实现）分配100的内存就够了呢？答案是否定的。因为将集合 B 添加到集合 A 中很可能就超过100个元素了。

还有，题目没有给定多少组测试数据，我们的方法就是判断是否读到了文件结尾。利用 scanf(“%d”,&m) != EOF 来作判断即可。

对于解本题的算法，题目描述中已经有了，我就不再赘述。除了基本操作以外，还要看怎么输出。实际上就是在每次插入后使用一个循环将集合 A 中的所有元素输出即可。

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;//把int重命名为ElemType
typedef struct
{
    int data[205];
    int length;
} List;//顺序表
int ListLength(List A);
int LocateElem(List A,ElemType e);
void Union(List &La,List Lb);
ElemType GetElem(List A,int i,ElemType e);
void ListInsert(List &A,int length,ElemType e);
int main (void)
{
    int n,m;
    List La,Lb;
    while(scanf("%d",&n)!=EOF)
    {
        //输入
        for(int i=0; i<n; i++)
        {
            scanf("%d",&La.data[i]);
        }
        La.length=n;
        scanf("%d",&m);
        for(int i=0; i<m; i++)
        {
            scanf("%d",&Lb.data[i]);
        }
        Lb.length=m;


        //输出
        for(int i=0; i<La.length; i++)
        {
            if(i==0)
                printf("%d",La.data[i]);
            else
                printf(" %d",La.data[i]);
        }
        printf("n");
        for(int i=0; i<ListLength(Lb); i++)
        {
            if(i==0)
                printf("%d",Lb.data[i]);
            else
                printf(" %d",Lb.data[i]);
        }
        printf("n");
        Union(La,Lb);
    }
    return 0;
}
//链表的引用型为List *&La 不用引用型是 List *La 
//顺序表引用型为List &La 不用引用型是 List La 
void Union(List &La,List Lb)//修改了La用引用型
{
    int La_len,Lb_len,i;
    ElemType e;
    La_len = ListLength(La);
    Lb_len = ListLength(Lb);
    for(i=0; i<Lb_len; i++)
    {
        e=GetElem(Lb,i,e);//直接传 e 不写return e是个乱码
        if(!LocateElem(La,e))///比较La 没有相同的插入
        {
            ListInsert(La,La.length,e);
        }
        //输出
        for(int i=0; i<La.length; i++)
        {
            if(i==0)
                printf("%d",La.data[i]);
        }
        printf("n");
    }
    printf("n");
}
int ListLength(List A)
{
    return A.length;
}
ElemType GetElem(List A,ElemType e)
{
    return e=A.data[i];
}
int LocateElem(List A,ElemType e )
{
    int i;
    for(i=0; i<ListLength(A); i++)
    {

        if(A.data[i]==e)
        {
            return 1;
        }
    }
    return 0;
}
void ListInsert(List &A,ElemType e)
{
    A.data[length] = e;
    ++(A.length);
}