请帮我用C++语言完成设计一个程序来实现集合（元素类型为int）的运算： 1. 生成两个存有集合的单链表A(4,1,2,3)和B(5,1,3,6)。 2. 实现A与B的并、交、差及判断相等的功能，并设计主函数对各功能进行测试。

为了帮你设计一个C++程序实现集合操作，我们首先需要创建一个链表结构存储整数，然后实现四个基本操作：并集、交集、差集以及判断两个链表是否相等。这里是一个简单的示例：

#include <iostream>
#include <vector>

// 定义链表节点
struct ListNode {
    int value;
    ListNode* next;
    ListNode(int val = 0) : value(val), next(nullptr) {}
};

// 创建链表函数
ListNode* createList(const std::vector<int>& values) {
    ListNode* head = nullptr;
    for (int val : values) {
        ListNode* newNode = new ListNode(val);
        if (!head) {
            head = newNode;
        } else {
            ListNode* temp = head;
            while (temp->next) {
                temp = temp->next;
            }
            temp->next = newNode;
        }
    }
    return head;
}

// 合并两个链表
ListNode* mergeLists(ListNode* a, ListNode* b) {
    if (!a) return b;
    if (!b) return a;
    if (a->value < b->value) {
        a->next = mergeLists(a->next, b);
        return a;
    } else {
        b->next = mergeLists(a, b->next);
        return b;
    }
}

// 判断两个链表相等
bool listsEqual(ListNode* a, ListNode* b) {
    while (a && b) {
        if (a->value != b->value) return false;
        a = a->next;
        b = b->next;
    }
    return !a && !b;
}

// 找到交集
ListNode* intersect(ListNode* list1, ListNode* list2) {
    ListNode* slow = list1, *fast = list1;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == list2) {
            break;
        }
    }
    if (!slow || !list2 || slow == list2) return nullptr;

    ListNode* result = nullptr;
    fast = list2;
    while (slow && fast) {
        if (slow->value == fast->value) {
            if (!result) {
                result = slow;
            } else {
                ListNode* temp = result;
                while (temp->next && temp->next->value != slow->value) {
                    temp = temp->next;
                }
                if (!temp->next) {
                    temp->next = slow;
                }
            }
        }
        slow = slow->next;
        fast = fast->next;
    }
    return result ? result : nullptr;
}

// 打印链表
void printList(ListNode* head) {
    while (head) {
        std::cout << head->value << " ";
        head = head->next;
    }
    std::cout << "\n";
}

int main() {
    // 创建链表A和B
    std::vector<int> A = {4, 1, 2, 3};
    std::vector<int> B = {5, 1, 3, 6};
    
    ListNode* listA = createList(A);
    ListNode* listB = createList(B);

    // 输出初始链表
    std::cout << "Original Lists:\n";
    printList(listA);
    printList(listB);

    // 并集
    ListNode* unionList = mergeLists(listA, listB);
    std::cout << "Union of A and B:\n";
    printList(unionList);

    // 交集
    ListNode* intersection = intersect(listA, listB);
    std::cout << "Intersection of A and B:\n";
    printList(intersection);

    // 判断是否相等
    bool equal = listsEqual(listA, listB);
    std::cout << "Are the lists A and B equal? " << (equal ? "Yes" : "No") << "\n";

    // 清理内存
    delete listA;
    delete listB;
    if (intersection) delete intersection;

    return 0;
}

这个程序首先创建了链表A和B，然后实现了并集、交集和判断相等的操作。请注意，对于实际应用，可能需要处理更复杂的情况，如处理空列表或链表大小不同等情况。现在你可以运行这个程序测试上述功能。下面是几个相关的测试问题：

1. 如果链表A和B为空，上述操作会怎样？
2. 如何优化查找交集的过程？
3. 是否可以将此代码扩展到支持其他数据类型的集合？