编写数据结构c语言代码求两个集合的交集和并集的运算。要求： (1)采用数据结构知识实现，不用系统自带的集合类。(2)能实现多组数据的多次运算，直到选择结束运算为止； (3)分析求交集和并集算法的时间复杂度和空间复杂度，给出优化分析； (4)提供问答界面，以便人机交互。

好的，下面是使用C语言实现两个集合的交集和并集的代码，同时提供人机交互的命令行界面：

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

#define MAX_SIZE 100

struct Set {
    int elements[MAX_SIZE];
    int size;
};

void add(struct Set *set, int element) {
    if (set->size >= MAX_SIZE) {
        printf("Set is full\n");
        return;
    }
    for (int i = 0; i < set->size; i++) {
        if (set->elements[i] == element) {
            return;
        }
    }
    set->elements[set->size++] = element;
}

void remove_element(struct Set *set, int element) {
    for (int i = 0; i < set->size; i++) {
        if (set->elements[i] == element) {
            set->elements[i] = set->elements[--set->size];
            return;
        }
    }
}

struct Set union_set(struct Set set1, struct Set set2) {
    struct Set result = set1;
    for (int i = 0; i < set2.size; i++) {
        add(&result, set2.elements[i]);
    }
    return result;
}

struct Set intersection(struct Set set1, struct Set set2) {
    struct Set result;
    for (int i = 0; i < set1.size; i++) {
        for (int j = 0; j < set2.size; j++) {
            if (set1.elements[i] == set2.elements[j]) {
                add(&result, set1.elements[i]);
            }
        }
    }
    return result;
}

void display(struct Set set) {
    printf("{ ");
    for (int i = 0; i < set.size; i++) {
        printf("%d ", set.elements[i]);
    }
    printf("}\n");
}

int main() {
    struct Set set1 = { .size = 0 };
    struct Set set2 = { .size = 0 };

    while (1) {
        printf("\nChoose an operation:\n");
        printf("1. Add elements to set 1\n");
        printf("2. Add elements to set 2\n");
        printf("3. Remove elements from set 1\n");
        printf("4. Remove elements from set 2\n");
        printf("5. Calculate union\n");
        printf("6. Calculate intersection\n");
        printf("7. Exit\n");

        int choice;
        scanf("%d", &choice);

        if (choice == 1) {
            printf("Enter elements separated by space: ");
            char input[100];
            scanf("%s", input);
            char *token = strtok(input, " ");
            while (token != NULL) {
                int element = atoi(token);
                add(&set1, element);
                token = strtok(NULL, " ");
            }
        }

        else if (choice == 2) {
            printf("Enter elements separated by space: ");
            char input[100];
            scanf("%s", input);
            char *token = strtok(input, " ");
            while (token != NULL) {
                int element = atoi(token);
                add(&set2, element);
                token = strtok(NULL, " ");
            }
        }

        else if (choice == 3) {
            printf("Enter element to remove: ");
            int element;
            scanf("%d", &element);
            remove_element(&set1, element);
        }

        else if (choice == 4) {
            printf("Enter element to remove: ");
            int element;
            scanf("%d", &element);
            remove_element(&set2, element);
        }

        else if (choice == 5) {
            struct Set result = union_set(set1, set2);
            printf("Union of set 1 and set 2: ");
            display(result);
        }

        else if (choice == 6) {
            struct Set result = intersection(set1, set2);
            printf("Intersection of set 1 and set 2: ");
            display(result);
        }

        else if (choice == 7) {
            break;
        }

        else {
            printf("Invalid choice\n");
        }
    }

    return 0;
}

时间复杂度分析：

1. 集合的添加和删除操作使用了数组，时间复杂度为O(n)，其中n为集合元素个数。

2. 集合的并集操作时间复杂度为O(m+n)，其中m和n分别为两个集合元素个数，因为需要遍历两个集合中的所有元素。

3. 集合的交集操作时间复杂度为O(mn)，其中m和n分别为两个集合元素个数，因为需要遍历其中一个集合中的所有元素，并在另一个集合中查找是否存在该元素。

空间复杂度分析：

1. 集合的添加和删除操作使用了数组，空间复杂度为O(n)，其中n为集合元素个数。

2. 集合的并集和交集操作需要创建新的集合，空间复杂度为O(m+n)，其中m和n分别为两个集合元素个数。

优化分析：

1. 可以使用哈希表或二叉搜索树代替数组，以提高添加、删除和查找元素的效率。

2. 对于集合元素个数较大的情况，可以使用并查集等数据结构进行优化。

3. 可以对集合元素进行排序，以减少查找次数。

4. 可以使用位运算等技巧对哈希表进行优化，提高查找效率。