6-2 顺序表(有序表)的合并(并集)*

已知顺序表的结构定义如下：

typedef struct
{
    int size, length;
    long long *element;
} LIST;

说明：参数 dst 为指示目标顺序表的指针，src1 和 src2 分别为指示两个源顺序表的指针。函数将 src1 和 src2 所指两个源顺序表合并到 dst 所指目标顺序表中。目标顺序表中保存两个源顺序表中的所有元素，但不重复。

函数原型

void Add(LIST *dst, const LIST *src1, const LIST *src2);

说明：参数 dst 为指示目标顺序表的指针，src1 和 src2 分别为指示两个源顺序表的指针。函数将 src1 和 src2 所指两个源顺序表合并到 dst 所指目标顺序表中。

裁判程序

int main()
{
    LIST a, b, c;
    Create(&a);
    Create(&b);
    Create(&c);
    Input(&a);
    Input(&b);
    Add(&c, &a, &b);
    Output(&c);
    putchar('\n');
    Destroy(&c);
    Destroy(&b);
    Destroy(&a);
    return 0;
}

说明：Create 函数用于创建顺序表，Destroy 函数用于销毁顺序表。Input 函数用于输入顺序表：首先输入元素个数，然后输入这些数据元素。Output 函数用于输出顺序表，数据元素之间以空格间隔。

输入样例

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

输出样例

1 2 3 4 5 6 7 8 9

完整代码： 

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

typedef struct
{
    int size;
    int length;
    long long* element;
} LIST;

void Create(LIST *lst)
{
    lst->size = 10;
    lst->length = 0;
    lst->element = (long long *)malloc(lst->size * sizeof(long long));
}

void Input(LIST *lst,int n)
{
    if (n > lst->size)
    {
        printf("输入的元素个数超过链表大小，请重新输入。\n");
        return;
    }

    for (int i = 0; i < n; i++)
    {
        scanf("%lld", &lst->element[i]);
    }
}

void Output(LIST *lst,int m)
{
    for (int i = 0; i <lst->length; i++)
    {
        printf("%d ", lst->element[i]);
    }
    printf("\n");
}

void Add(LIST *src1, LIST *src2,  LIST *dst)
{
    int i, j = 0;
    int k=0;
    for (i = 0; i < src1->length; i++)
    {
        for (j = 0; j < dst->length; j++) //找出相同元素的位置
        {
            if (src1->element[i] == dst->element[j])
                break;
        }
        if (j == dst->length) //当dst没有scr1的元素时，将scr1的元素插入到dst表中
        {
            dst->element[k++] = src1->element[i];
            dst->length++;//不要忘记dst的长度以改变
        }
    }

    for (i = 0; i < src2->length; i++)
    {
        for (j = 0; j < dst->length; j++)
        {
            if (src2->element[i] == dst->element[j])
                break;
        }
        if (j == dst->length)
        {
            dst->element[k++] = src2->element[i];
            dst->length++;
        }
    }
}

void bubble_sort(LIST *dst, int n) {//冒泡排序
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (dst->element[j] > dst->element[j + 1]) {//交换位置
                int temp = dst->element[j];
                dst->element[j] = dst->element[j + 1];
                dst->element[j + 1] = temp;
            }
        }
    }
}

void Destroy(LIST *lst)
{
    free(lst->element);
}

int main()
{

    LIST a, b, c;
    int x,h;
    Create(&a);
    Create(&b);
    Create(&c);
    printf("请输入链表a的元素个数：");
    int n;
    scanf("%d", &n);
    a.length=n;
    Input(&a,n);
    Output(&a,n);
    printf("请输入链表b的元素个数：");
    scanf("%d", &x);
    b.length=x;
    Input(&b,x);
    Output(&b,x);
    Add(&a, &b, &c);
    h=c.length;
    printf("合并后的链表为：");
     bubble_sort(&c,h);
    Output(&c,h);
    Destroy(&a);
    Destroy(&b);
    Destroy(&c);
    return 0;
}

答案代码： 

//两个源列表 src1 和 src2 以及一个目标列表 dst。
void Add(LIST *src1, LIST *src2,  LIST *dst)
{
//其中 i 和 j 用于循环.
//而 k 用于跟踪目标列表 dst 的当前长度。
    int i, j = 0;
    int k=0;
//遍历源列表 src1。
    for (i = 0; i < src1->length; i++)
    {
//对于每个源列表中的元素，遍历目标列表 dst 以查找是否有相同的元素。
        for (j = 0; j < dst->length; j++)
        {
//如果找到相同的元素，则跳出内层循环。
            if (src1->element[i] == dst->element[j])//注意i和j的区分
                break;
        }
//检查是否遍历了整个目标列表而没有找到相同的元素。
        if (j == dst->length)
        {
//如果上述条件满足，则将源列表中的元素添加到目标列表中，并增加目标列表的长度。
            dst->element[k++] = src1->element[i];
            dst->length++;//不要忘记dst的长度已改变
        }
    }
//用相同的方法处理表2
    for (i = 0; i < src2->length; i++)
    {
        for (j = 0; j < dst->length; j++)
        {
            if (src2->element[i] == dst->element[j])
                break;
        }
        if (j == dst->length)
        {
            dst->element[k++] = src2->element[i];
            dst->length++;
        }
    }
}