C语言单链表实现对称差

Question

#include<stdio.h>
#include<malloc.h>
typedef struct LNode {
    int data;
    struct LNode* next;
}LNode, * LinkList;

int InitList_L(LinkList& L);
void CreatList(LinkList& L, int n);
void PrintList(LinkList L);

int main() {
    LinkList L1,L2;
    int i=0,n1,n2;

    InitList_L(L1);
    InitList_L(L2);

    printf("L1中的数据个数\n");
    scanf("%d",&n1);
    CreatList(L1,n1);
    
    printf("L2中的数据个数\n");
    scanf("%d", &n2);
    CreatList(L2, n2);

    printf("L1的数据：\n");
    PrintList(L1);
    printf("L2的数据：\n");
    PrintList(L2);
    

    return 0;
}
//初始化
int InitList_L(LinkList& L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    return 1;
}
//头插法建立单链表
void CreatList(LinkList& L, int n) {
    int i;
    LNode* p;
    for (i = n; i > 0; --i) {
        p = (LNode*)malloc(sizeof(struct LNode));
        p->next = NULL;
        scanf("%d", &p->data);
        p->next = L->next;//插入到表头
        L->next = p;
    }
}
//打印
void PrintList(LinkList L)
{
    LinkList p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

对称差的函数咋写

Answer 1

供参考：

//对称差 : A , B 是两个集合 , 属于 A 集合而不属于 B 集合 ,
//属于B 集合而不属于 A 集合的全体元素,组成的集合称为 A 与 B 的对称差 ;
//(A-B)∪(B-A) : A 对 B 的相对补集 , 与 B 对 A 的相对补集  的并集 ;

#include<stdio.h>
#include<malloc.h>
typedef struct LNode {
    int    data;
    struct LNode* next;
}LNode, * LinkList;

int  InitList_L(LinkList& L);
void CreatList(LinkList& L, int n);
void PrintList(LinkList L);
void DifferenceList(LinkList La,LinkList Lb,LinkList Lc);
void UnionList(LinkList La,LinkList Lb,LinkList Lc);
int main()
{
    LinkList L1,L2,L3,L4,L5;//L3=L1-L2,L4=L2-L1
    int i=0,n1,n2;
    InitList_L(L1);
    InitList_L(L2);
    printf("L1中的数据个数\n");
    scanf("%d",&n1);
    CreatList(L1,n1);
    printf("L2中的数据个数\n");
    scanf("%d", &n2);
    CreatList(L2, n2);
    printf("L1的数据：\n");
    PrintList(L1);
    printf("L2的数据：\n");
    PrintList(L2);

    InitList_L(L3);
    InitList_L(L4);
    DifferenceList(L1,L2,L3);
    DifferenceList(L2,L1,L4);
    printf("L1与L2差集 L3的数据：\n");
    PrintList(L3);
    printf("L2与L1差集 L4的数据：\n");
    PrintList(L4);

    InitList_L(L5);
    printf("L1与L2对称差 L5的数据：\n");
    UnionList(L3,L4,L5);
    PrintList(L5);
    
    return 0;
}
//初始化
int InitList_L(LinkList& L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    return 1;
}
//头插法建立单链表
void CreatList(LinkList& L, int n) {
    int i;
    LNode* p;
    for (i = n; i > 0; --i) {
        p = (LNode*)malloc(sizeof(struct LNode));
        p->next = NULL;
        scanf("%d", &p->data);
        p->next = L->next;//插入到表头
        L->next = p;
    }
}
//打印
void PrintList(LinkList L)
{
    LinkList p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

//属于A且不属于B的元素组成的集合，叫做集合A减集合B(或集合A与集合B之差)。
// A={1，2，3} ，B={3，4，5} ,A-B={1，2} 。
void DifferenceList(LinkList La,LinkList Lb,LinkList Lc)//Lc = La - Lb
{
    LNode *pa,*pb,*pc;
    int count;
    pa = La->next;
    pc = Lc->next;
    while(pa){
        count = 0;
        pb = Lb->next;
        while(pb){
            if(pa->data==pb->data)
                count++;
            pb=pb->next;
        }
        if(count==0){
            pc = (LNode *)malloc(sizeof(LNode));
            pc->data = pa->data;
            pc->next = Lc->next;
            Lc->next = pc;
        }
        pa = pa->next;
    }
}

void UnionList(LinkList La,LinkList Lb,LinkList Lc)//并集
{
     LNode *pa=La->next,*pb=Lb->next,*pc=Lc;
     while(pa)
     {
           LNode *pt = (LNode*)malloc(sizeof(LNode));
           pt->next = NULL;
           pt->data = pa->data;
           pc->next = pt;
           pc = pt;
           pa = pa->next;
     }
     while(pb)
     {
           pa = Lc->next;
           while(pa)
           {
                if(pb->data == pa->data) break;
                pa = pa->next;
           }
           if (pa == NULL)
           {
               LNode *pt = (LNode*)malloc(sizeof(LNode));
               pt->next = NULL;
               pt->data = pb->data;
               pc->next = pt;
               pc = pt;
           }
           pb = pb->next;
     }
}