c语言求并集时如何去掉相同数

使用C语言求并集时去掉相同数的方法主要有：使用哈希表、排序后合并、直接遍历去重。在实际应用中，使用哈希表是常见且高效的方法，因为它能够在常数时间内检查元素是否已经存在。下面详细介绍这种方法。

哈希表是一种数据结构，它能快速地进行插入和查找操作。通过将元素插入哈希表，我们可以确保每个元素只出现一次，从而达到去重的效果。

一、使用哈希表求并集并去重

1. 初始化哈希表

在C语言中，我们可以使用标准库中的哈希表或自己实现一个简单的哈希表。哈希表的关键在于选择一个好的哈希函数和处理冲突的方法。

#include <stdio.h>
#include <stdlib.h>
#define TABLE_SIZE 100
typedef struct HashNode {
    int data;
    struct HashNode* next;
} HashNode;
typedef struct HashTable {
    HashNode* table[TABLE_SIZE];
} HashTable;
unsigned int hash(int key) {
    return key % TABLE_SIZE;
}
HashTable* createHashTable() {
    HashTable* ht = (HashTable*)malloc(sizeof(HashTable));
    for (int i = 0; i < TABLE_SIZE; i++) {
        ht->table[i] = NULL;
    }
    return ht;
}
void insert(HashTable* ht, int key) {
    unsigned int hashValue = hash(key);
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->data = key;
    newNode->next = ht->table[hashValue];
    ht->table[hashValue] = newNode;
}
int search(HashTable* ht, int key) {
    unsigned int hashValue = hash(key);
    HashNode* node = ht->table[hashValue];
    while (node != NULL) {
        if (node->data == key) {
            return 1;
        }
        node = node->next;
    }
    return 0;
}

2. 合并数组并去重

使用哈希表对两个数组进行合并，并在插入时检查元素是否已经存在。

void unionArrays(int* arr1, int size1, int* arr2, int size2) {
    HashTable* ht = createHashTable();
    printf("Union of arrays: ");
    for (int i = 0; i < size1; i++) {
        if (!search(ht, arr1[i])) {
            insert(ht, arr1[i]);
            printf("%d ", arr1[i]);
        }
    }
    for (int i = 0; i < size2; i++) {
        if (!search(ht, arr2[i])) {
            insert(ht, arr2[i]);
            printf("%d ", arr2[i]);
        }
    }
    printf("n");
}
int main() {
    int arr1[] = {1, 2, 3, 4, 5};
    int arr2[] = {4, 5, 6, 7, 8};
    unionArrays(arr1, 5, arr2, 5);
    return 0;
}

二、排序后合并

1. 排序数组

先对两个数组进行排序，然后合并两个已排序的数组，过程中跳过重复元素。

#include <stdio.h>
#include <stdlib.h>
int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}
void unionSortedArrays(int* arr1, int size1, int* arr2, int size2) {
    qsort(arr1, size1, sizeof(int), compare);
    qsort(arr2, size2, sizeof(int), compare);
    int i = 0, j = 0;
    printf("Union of arrays: ");
    while (i < size1 && j < size2) {
        if (arr1[i] < arr2[j]) {
            printf("%d ", arr1[i]);
            i++;
        } else if (arr1[i] > arr2[j]) {
            printf("%d ", arr2[j]);
            j++;
        } else {
            printf("%d ", arr1[i]);
            i++;
            j++;
        }
    }
    while (i < size1) {
        printf("%d ", arr1[i]);
        i++;
    }
    while (j < size2) {
        printf("%d ", arr2[j]);
        j++;
    }
    printf("n");
}
int main() {
    int arr1[] = {1, 2, 3, 4, 5};
    int arr2[] = {4, 5, 6, 7, 8};
    unionSortedArrays(arr1, 5, arr2, 5);
    return 0;
}

三、直接遍历去重

1. 遍历数组

不使用任何辅助数据结构，直接遍历数组并进行去重。这种方法在效率上较低，但实现简单。

#include <stdio.h>
void unionDirect(int* arr1, int size1, int* arr2, int size2) {
    int i, j;
    int flag;
    printf("Union of arrays: ");
    for (i = 0; i < size1; i++) {
        printf("%d ", arr1[i]);
    }
    for (i = 0; i < size2; i++) {
        flag = 1;
        for (j = 0; j < size1; j++) {
            if (arr2[i] == arr1[j]) {
                flag = 0;
                break;
            }
        }
        if (flag) {
            printf("%d ", arr2[i]);
        }
    }
    printf("n");
}
int main() {
    int arr1[] = {1, 2, 3, 4, 5};
    int arr2[] = {4, 5, 6, 7, 8};
    unionDirect(arr1, 5, arr2, 5);
    return 0;
}

四、总结与推荐

通过上述三种方法，可以有效地求出两个数组的并集并去掉相同数。使用哈希表是效率最高的方法，适用于数据量较大的场景；排序后合并适合需要保持有序性的场景；直接遍历去重方法简单，但效率较低，适合数据量较小的情况。在实际项目管理中，如需使用研发项目管理系统PingCode或通用项目管理软件Worktile，可以根据项目需求灵活选用不同的去重方法。

在编写代码时，应根据具体需求选择合适的数据结构和算法，以达到最佳的性能和可维护性。