1. PingCode智库首页
  2. 百科

c语言中交和并如何表示

Edit2 • • 百科

c语言中交和并如何表示

在C语言中，交和并主要通过集合操作来实现。交集、并集、差集和对称差集是常用的集合操作，其中，交集是两个集合中都存在的元素，并集是两个集合中所有元素的集合。在实现这些集合操作时，通常使用数组或链表来存储集合，并使用嵌套循环、查找和插入等基本操作来完成集合的交集和并集操作。

一、C语言中的集合表示

在C语言中，集合可以使用不同的数据结构来表示。常用的数据结构包括数组和链表。数组是一种简单且高效的集合表示方式，适用于已知大小的集合。链表则适用于大小不固定的集合。以下是两种表示方式的示例：

1、使用数组表示集合

数组是一种连续存储的结构，适合存储元素数量已知的集合。以下是一个使用数组表示集合的示例：

#include <stdio.h>


#define MAX_SIZE 100


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++) {


        printf("%d ", arr[i]);


    }


    printf("n");


}


int main() {


    int setA[MAX_SIZE] = {1, 2, 3, 4, 5};


    int setB[MAX_SIZE] = {4, 5, 6, 7, 8};


    int sizeA = 5;


    int sizeB = 5;


    printf("Set A: ");


    printArray(setA, sizeA);


    printf("Set B: ");


    printArray(setB, sizeB);


    return 0;


}

2、使用链表表示集合

链表是一种链式存储的结构，适合存储元素数量不确定的集合。以下是一个使用链表表示集合的示例：

#include <stdio.h>


#include <stdlib.h>


struct Node {


    int data;


    struct Node* next;


};


void printList(struct Node* head) {


    struct Node* temp = head;


    while (temp != NULL) {


        printf("%d ", temp->data);


        temp = temp->next;


    }


    printf("n");


}


int main() {


    struct Node* setA = (struct Node*)malloc(sizeof(struct Node));


    struct Node* setB = (struct Node*)malloc(sizeof(struct Node));


    setA->data = 1;


    setA->next = (struct Node*)malloc(sizeof(struct Node));


    setA->next->data = 2;


    setA->next->next = NULL;


    setB->data = 4;


    setB->next = (struct Node*)malloc(sizeof(struct Node));


    setB->next->data = 5;


    setB->next->next = NULL;


    printf("Set A: ");


    printList(setA);


    printf("Set B: ");


    printList(setB);


    return 0;


}

二、交集操作

交集是两个集合中都存在的元素。以下是使用数组和链表实现集合交集的示例：

1、使用数组实现交集

#include <stdio.h>


#define MAX_SIZE 100


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++) {


        printf("%d ", arr[i]);


    }


    printf("n");


}


void intersection(int setA[], int sizeA, int setB[], int sizeB) {


    int result[MAX_SIZE];


    int sizeResult = 0;


    for (int i = 0; i < sizeA; i++) {


        for (int j = 0; j < sizeB; j++) {


            if (setA[i] == setB[j]) {


                result[sizeResult++] = setA[i];


                break;


            }


        }


    }


    printf("Intersection: ");


    printArray(result, sizeResult);


}


int main() {


    int setA[MAX_SIZE] = {1, 2, 3, 4, 5};


    int setB[MAX_SIZE] = {4, 5, 6, 7, 8};


    int sizeA = 5;


    int sizeB = 5;


    intersection(setA, sizeA, setB, sizeB);


    return 0;


}

2、使用链表实现交集

#include <stdio.h>


#include <stdlib.h>


struct Node {


    int data;


    struct Node* next;


};


void printList(struct Node* head) {


    struct Node* temp = head;


    while (temp != NULL) {


        printf("%d ", temp->data);


        temp = temp->next;


    }


    printf("n");


}


struct Node* intersection(struct Node* setA, struct Node* setB) {


    struct Node* result = NULL;


    struct Node lastPtrRef = &result;


    struct Node* a = setA;


    struct Node* b = setB;


    while (a != NULL && b != NULL) {


        if (a->data < b->data) {


            a = a->next;


        } else if (a->data > b->data) {


            b = b->next;


        } else {


            struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));


            newNode->data = a->data;


            newNode->next = NULL;


            *lastPtrRef = newNode;


            lastPtrRef = &(newNode->next);


            a = a->next;


            b = b->next;


        }


    }


    return result;


}


int main() {


    struct Node* setA = (struct Node*)malloc(sizeof(struct Node));


    setA->data = 1;


    setA->next = (struct Node*)malloc(sizeof(struct Node));


    setA->next->data = 2;


    setA->next->next = (struct Node*)malloc(sizeof(struct Node));


    setA->next->next->data = 4;


    setA->next->next->next = NULL;


    struct Node* setB = (struct Node*)malloc(sizeof(struct Node));


    setB->data = 2;


    setB->next = (struct Node*)malloc(sizeof(struct Node));


    setB->next->data = 4;


    setB->next->next = (struct Node*)malloc(sizeof(struct Node));


    setB->next->next->data = 5;


    setB->next->next->next = NULL;


    struct Node* result = intersection(setA, setB);


    printf("Intersection: ");


    printList(result);


    return 0;


}

三、并集操作

并集是两个集合中所有元素的集合。以下是使用数组和链表实现集合并集的示例：

1、使用数组实现并集

#include <stdio.h>


#define MAX_SIZE 100


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++) {


        printf("%d ", arr[i]);


    }


    printf("n");


}


void unionSet(int setA[], int sizeA, int setB[], int sizeB) {


    int result[MAX_SIZE];


    int sizeResult = 0;


    for (int i = 0; i < sizeA; i++) {


        result[sizeResult++] = setA[i];


    }


    for (int i = 0; i < sizeB; i++) {


        int j;


        for (j = 0; j < sizeA; j++) {


            if (setB[i] == setA[j]) {


                break;


            }


        }


        if (j == sizeA) {


            result[sizeResult++] = setB[i];


        }


    }


    printf("Union: ");


    printArray(result, sizeResult);


}


int main() {


    int setA[MAX_SIZE] = {1, 2, 3, 4, 5};


    int setB[MAX_SIZE] = {4, 5, 6, 7, 8};


    int sizeA = 5;


    int sizeB = 5;


    unionSet(setA, sizeA, setB, sizeB);


    return 0;


}

2、使用链表实现并集

#include <stdio.h>


#include <stdlib.h>


struct Node {


    int data;


    struct Node* next;


};


void printList(struct Node* head) {


    struct Node* temp = head;


    while (temp != NULL) {


        printf("%d ", temp->data);


        temp = temp->next;


    }


    printf("n");


}


struct Node* unionSet(struct Node* setA, struct Node* setB) {


    struct Node* result = NULL;


    struct Node lastPtrRef = &result;


    struct Node* a = setA;


    while (a != NULL) {


        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));


        newNode->data = a->data;


        newNode->next = NULL;


        *lastPtrRef = newNode;


        lastPtrRef = &(newNode->next);


        a = a->next;


    }


    struct Node* b = setB;


    while (b != NULL) {


        struct Node* a = setA;


        while (a != NULL && a->data != b->data) {


            a = a->next;


        }


        if (a == NULL) {


            struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));


            newNode->data = b->data;


            newNode->next = NULL;


            *lastPtrRef = newNode;


            lastPtrRef = &(newNode->next);


        }


        b = b->next;


    }


    return result;


}


int main() {


    struct Node* setA = (struct Node*)malloc(sizeof(struct Node));


    setA->data = 1;


    setA->next = (struct Node*)malloc(sizeof(struct Node));


    setA->next->data = 2;


    setA->next->next = (struct Node*)malloc(sizeof(struct Node));


    setA->next->next->data = 4;


    setA->next->next->next = NULL;


    struct Node* setB = (struct Node*)malloc(sizeof(struct Node));


    setB->data = 2;


    setB->next = (struct Node*)malloc(sizeof(struct Node));


    setB->next->data = 4;


    setB->next->next = (struct Node*)malloc(sizeof(struct Node));


    setB->next->next->data = 5;


    setB->next->next->next = NULL;


    struct Node* result = unionSet(setA, setB);


    printf("Union: ");


    printList(result);


    return 0;


}

四、差集和对称差集操作

差集是一个集合中有但另一个集合中没有的元素，对称差集是两个集合中互相没有的元素。以下是实现差集和对称差集的示例：

1、使用数组实现差集和对称差集

#include <stdio.h>


#define MAX_SIZE 100


void printArray(int arr[], int size) {


    for (int i = 0; i < size; i++) {


        printf("%d ", arr[i]);


    }


    printf("n");


}


void difference(int setA[], int sizeA, int setB[], int sizeB) {


    int result[MAX_SIZE];


    int sizeResult = 0;


    for (int i = 0; i < sizeA; i++) {


        int j;


        for (j = 0; j < sizeB; j++) {


            if (setA[i] == setB[j]) {


                break;


            }


        }


        if (j == sizeB) {


            result[sizeResult++] = setA[i];


        }


    }


    printf("Difference: ");


    printArray(result, sizeResult);


}


void symmetricDifference(int setA[], int sizeA, int setB[], int sizeB) {


    int result[MAX_SIZE];


    int sizeResult = 0;


    for (int i = 0; i < sizeA; i++) {


        int j;


        for (j = 0; j < sizeB; j++) {


            if (setA[i] == setB[j]) {


                break;


            }


        }


        if (j == sizeB) {


            result[sizeResult++] = setA[i];


        }


    }


    for (int i = 0; i < sizeB; i++) {


        int j;


        for (j = 0; j < sizeA; j++) {


            if (setB[i] == setA[j]) {


                break;


            }


        }


        if (j == sizeA) {


            result[sizeResult++] = setB[i];


        }


    }


    printf("Symmetric Difference: ");


    printArray(result, sizeResult);


}


int main() {


    int setA[MAX_SIZE] = {1, 2, 3, 4, 5};


    int setB[MAX_SIZE] = {4, 5, 6, 7, 8};


    int sizeA = 5;


    int sizeB = 5;


    difference(setA, sizeA, setB, sizeB);


    symmetricDifference(setA, sizeA, setB, sizeB);


    return 0;


}

2、使用链表实现差集和对称差集

#include <stdio.h>


#include <stdlib.h>


struct Node {


    int data;


    struct Node* next;


};


void printList(struct Node* head) {


    struct Node* temp = head;


    while (temp != NULL) {


        printf("%d ", temp->data);


        temp = temp->next;


    }


    printf("n");


}


struct Node* difference(struct Node* setA, struct Node* setB) {


    struct Node* result = NULL;


    struct Node lastPtrRef = &result;


    struct Node* a = setA;


    while (a != NULL) {


        struct Node* b = setB;


        while (b != NULL && b->data != a->data) {


            b = b->next;


        }


        if (b == NULL) {


            struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));


            newNode->data = a->data;


            newNode->next = NULL;


            *lastPtrRef = newNode;


            lastPtrRef = &(newNode->next);


        }


        a = a->next;


    }


    return result;


}


struct Node* symmetricDifference(struct Node* setA, struct Node* setB) {


    struct Node* result = NULL;


    struct Node lastPtrRef = &result;


    struct Node* a = setA;


    while (a != NULL) {


        struct Node* b = setB;


        while (b != NULL && b->data != a->data) {


            b = b->next;


        }


        if (b == NULL) {


            struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));


            newNode->data = a->data;


            newNode->next = NULL;


            *lastPtrRef = newNode;


            lastPtrRef = &(newNode->next);


        }


        a = a->next;


    }


    struct Node* b = setB;


    while (b != NULL) {


        struct Node* a = setA;


        while (a != NULL && a->data != b->data) {


            a = a->next;


        }


        if (a == NULL) {


            struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));


            newNode->data = b->data;


            newNode->next = NULL;


            *lastPtrRef = newNode;


            lastPtrRef = &(newNode->next);


        }


        b = b->next;


    }


    return result;


}


int main() {


    struct Node* setA = (struct Node*)malloc(sizeof(struct Node));


    setA->data = 1;


    setA->next = (struct Node*)malloc(sizeof(struct Node));


    setA->next->data = 2;


    setA->next->next = (struct Node*)malloc(sizeof(struct Node));


    setA->next->next->data = 4;


    setA->next->next->next = NULL;


    struct Node* setB = (struct Node*)malloc(sizeof(struct Node));


    setB->data = 2;


    setB->next = (struct Node*)malloc(sizeof(struct Node));


    setB->next->data = 4;


    setB->next->next = (struct Node*)malloc(sizeof(struct Node));


    setB->next->next->data = 5;


    setB->next->next->next = NULL;


    struct Node* resultDiff = difference(setA, setB);


    struct Node* resultSymDiff = symmetricDifference(setA, setB);


    printf("Difference: ");


    printList(resultDiff);


    printf("Symmetric Difference: ");


    printList(resultSymDiff);


    return 0;


}

五、优化和总结

1、性能优化

在处理大集合时，可以通过使用哈希表来提高查找效率，从而优化交集和并集操作的性能。哈希表可以在常数时间内完成查找操作，从而使交集和并集操作的时间复杂度降低到线性时间。

2、总结

C语言中，集合操作的实现主要依赖于数组和链表两种数据结构。交集、并集、差集和对称差集是常用的集合操作，它们可以通过嵌套循环、查找和插入等基本操作来实现。对于大规模数据集，可以通过使用哈希表等高级数据结构来优化性能。此外，在实际开发中，选择合适的数据结构和算法是提高程序性能和可维护性的关键。

在实际项目管理中，如需要处理复杂的集合操作和项目管理需求，可以考虑使用专业的项目管理系统，如研发项目管理系统PingCode和通用项目管理软件Worktile，这些工具能够提供更高效和便捷的项目管理解决方案。

相关问答FAQs：

1. 交和并在C语言中如何表示？
交和并是集合论中的基本操作，可以在C语言中通过数组和循环来实现。交集是指两个集合中共同存在的元素，而并集是指两个集合中所有的元素的集合。

2. 如何表示两个集合的交集？
要表示两个集合的交集，可以先将两个集合的元素分别存储在两个数组中，然后使用双重循环遍历这两个数组。在循环中，比较两个数组中的元素，如果相同，则将该元素存储到另一个数组中，即为两个集合的交集。

3. 如何表示两个集合的并集？
要表示两个集合的并集，可以先将两个集合的元素分别存储在两个数组中，然后使用循环遍历其中一个数组。在循环中，将该数组中的元素逐个存储到另一个数组中。接着，再遍历另一个数组，将不重复的元素存储到新的数组中。最后得到的数组即为两个集合的并集。

原创文章，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/1040831

赞 (0)
Edit2Edit2
上一篇 2024年8月27日 下午4:35
下一篇 2024年8月27日 下午4:35
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部