数据结构中集合运算（c++类实现class）交集并集差集子集包含判断

提供数据结构中集合的所有运算（c++类实现）

直接提供源代码，c++编译器可直接运行，楼主编译器采用Clion。
该代码设计数据结构中集合的所有基本运算，包括交集，并集，差集，集合包含判断（子集判断）在集合中查找元素（采用二分查找binary_search）即集合元素显示功能，链表采用头插法的单项链表，使用插入排序的功能实现了输入链时自动有序（降序排列）全程使用c++ OOP面向对象思想class类实现，适用于数据结构短学期实验项目等。
函数结构函数如下图，整个源程序共508行。

源代码：

/**
 * @author zxx
 * @date 2020-7-8
 */
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<vector>
#include<sstream>
#include<string>
using namespace std;
typedef int Status;
typedef char ElemType;
vector<char> vt;
vector<char> vt1;
typedef class LNode {
public:
    ElemType data;
    LNode* next;
}LNode, * LinkList;
class fun {
public:
    void show();    //功能界面操作提示
    Status input(LinkList& L, string n,int x); // 输⼊
    void Output(LinkList& L); //输出
    Status ClearList_L(LinkList& L); //链表清空
    void and_set(LinkList La, LinkList Lb, LinkList& Lc); //并集
    void intersection(LinkList La, LinkList Lb, LinkList& Lc); //交集
    void difference_set(LinkList La, LinkList Lb, LinkList& Lc); //差集
    bool if_exit(LinkList La, LinkList Lb, int cnt); //⼦集判断
    void query();  //二分查找
}obj;

//空链表初始化
Status Init_LinkList(LinkList& L) {
    LinkList p;
    p = (LinkList) malloc(sizeof(LNode));
    if (!p)
        return -1;
    L = p;
    L->next = NULL;
    return 1;
}

void fun::show() {
    printf("\t\t*********集合运算************\n");
    printf("\n");
    printf("\t\t\t1 集合A数据输⼊\n");
    printf("\t\t\t2 集合B数据输⼊\n");
    printf("\t\t\t3 集合A数据显示\n");
    printf("\t\t\t4 集合B数据显示\n");
    printf("\t\t\t5 集合A和集合B的并集\n");
    printf("\t\t\t6 集合A和集合B的交集\n");
    printf("\t\t\t7 集合A和集合B的差集\n");
    printf("\t\t\t8 集合A是否是集合B的⼦集\n");
    printf("\t\t\t9 集合B是否是集合A的⼦集\n");
    printf("\t\t\t10 查询集合中的某元素\n");
    printf("\t\t\t0 退出系统\n");
    printf("\n");
    printf("\t\t*********集合运算*************\n");
    printf("\n");
}

vector<char> zxx(LinkList& La) {
    if (La->next != NULL) {
        vector<char> v;
        LinkList p;
        for (p = La->next; p != NULL; p = p->next) {
            v.push_back(p->data);
        }
        vector<char>::iterator it;
        for (int i = 0; i < v.size(); ++i) {
            int cnt = 0;
            for (it = v.begin(); it != v.end();) {
                if (v[i] == *it) {
                    cnt++;
                    if (cnt == 2) {
                        v.erase(it);
                        cnt = 1;
                    } else it++;
                } else it++;
            }
        }
        return v;
    }
}

Status fun::input(LinkList& L, string n,int x) {
    if (x == 1) {
        stringstream ss(n);
        LinkList p;
        char i;
        while (ss >> i) {
            vt.push_back(i);
        }
        //插入排序
        for (int i = 1; i < vt.size(); ++i) {
            int temp = vt[i];
            int j = i;
            while (j > 0 && temp < vt[j - 1]) {
                vt[j] = vt[j - 1];
                j--;
            }
            vt[j] = temp;
        }
        int cnt = 0;
        while (cnt != vt.size()) {
            p = (LinkList) malloc(sizeof(LNode));
            if (p != NULL) {
                p->data = vt[cnt];
                p->next = L->next;
                L->next = p;
            } else return -1;
            cnt++;
        }
        vt = zxx(L);
        ClearList_L(L);
        cnt = 0;
        while (cnt != vt.size()) {
            p = (LinkList) malloc(sizeof(LNode));
            if (p != NULL) {
                p->data = vt[cnt];
                p->next = L->next;
                L->next = p;
            } else return -1;
            cnt++;
        }
    } else if (x == 2) {
        stringstream ss(n);
        LinkList p;
        char i;
        while (ss >> i) {
            vt1.push_back(i);
        }
        //插入排序
        for (int i = 1; i < vt1.size(); ++i) {
            int temp = vt1[i];
            int j = i;
            while (j > 0 && temp < vt1[j - 1]) {
                vt1[j] = vt1[j - 1];
                j--;
            }
            vt1[j] = temp;
        }
        int cnt = 0;
        while (cnt != vt1.size()) {
            p = (LinkList) malloc(sizeof(LNode));
            if (p != NULL) {
                p->data = vt1[cnt];
                p->next = L->next;
                L->next = p;
            } else return -1;
            cnt++;
        }
        vt1 = zxx(L);
        ClearList_L(L);
        cnt = 0;
        while (cnt != vt1.size()) {
            p = (LinkList) malloc(sizeof(LNode));
            if (p != NULL) {
                p->data = vt1[cnt];
                p->next = L->next;
                L->next = p;
            } else return -1;
            cnt++;
        }
    }
    printf("集合输⼊完成！\n");
    return 1;
}

void fun::Output(LinkList& L) {
    LinkList p;
    if (L->next == NULL)
        printf("该链表是空链表!\n");
    else {
        for (p = L->next; p != NULL; p = p->next) {
            cout << p->data << ' ';
        }
        cout << endl;
    }
}

bool fun::if_exit(LinkList a, LinkList b, int cnt) {
    if (cnt == 1) {
        if (a->next == NULL) return true;
        if (b->next == NULL) return false;
        LinkList p, p1;
        vector<int> vt;
        for (p = a->next; p != NULL; p = p->next) {
            vt.push_back(p->data);
        }
        int key;
        for (int i = 0; i < vt.size(); ++i) {
            key = 0;
            for (p1 = b->next; p1 != NULL; p1 = p1->next) {
                if (vt[i] == p1->data) {
                    key = 1;
                    break;
                }
            }
            if (key == 0) return false;
        }
        if (key) return true;
        else return false;
    } else if (cnt == 2) {
        if (a->next == NULL) return false;
        if (b->next == NULL) return true;
        LinkList p, p1;
        vector<int> vt;
        for (p = b->next; p != NULL; p = p->next) {
            vt.push_back(p->data);
        }
        int key;
        for (int i = 0; i < vt.size(); ++i) {
            key = 0;
            for (p1 = a->next; p1 != NULL; p1 = p1->next) {
                if (vt[i] == p1->data) {
                    key = 1;
                    break;
                }
            }
            if (key == 0) return false;
        }
        if (key) return true;
        else return false;
    }
}

Status fun::ClearList_L(LinkList& L) {
    LinkList p, q;
    p = L->next;
    if (!p)
        return 1;
    while (p) {
        q = p;
        p = p->next;
        free(q);
    }
    L->next = NULL;
    return 1;
}
void fun::and_set(LinkList La, LinkList Lb, LinkList& Lc) {
    if (Lc->next != NULL)
        obj.ClearList_L(Lc);
    LinkList p, q, s;
    p = La->next;
    while (p) {
        q = Lc->next;
        while (q && (q->data != p->data))
            q = q->next;
        if (q == NULL) {
            s = (LinkList) malloc(sizeof(LNode));
            s->data = p->data;
            s->next = Lc->next;
            Lc->next = s;
        }
        p = p->next;
    }
    p = Lb->next;
    while (p) {
        q = Lc->next;
        while (q && (q->data != p->data))
            q = q->next;
        if (q == NULL) {
            s = (LinkList) malloc(sizeof(LNode));
            s->data = p->data;
            s->next = Lc->next;
            Lc->next = s;
        }
        p = p->next;
    }
}
void fun::intersection(LinkList La, LinkList Lb, LinkList& Lc) {
    LinkList p, q, s, k;
    if (Lc->next)
        obj.ClearList_L(Lc);
    p = La->next;
    while (p) {
        q = Lb->next;
        while (q) {
            if (p->data == q->data)
                break;
            else q = q->next;
        }
        if (q) {
            s = Lc->next;
            while (s) {
                if (s->data == p->data)
                    break;
                else
                    s = s->next;
            }
            if (s == NULL) {
                k = (LinkList) malloc(sizeof(LNode));
                k->data = p->data;
                k->next = Lc->next;
                Lc->next = k;
            }
        }
        p = p->next;
    }
}
void fun::difference_set(LinkList La, LinkList Lb, LinkList& Lc) {
    LinkList p, q, s, k;
    if (Lc->next)
        obj.ClearList_L(Lc);
    p = La->next;
    while (p != NULL) {
        q = Lb->next;
        while (q != NULL) {
            if (q->data == p->data)
                break;
            else
                q = q->next;
        }
        if (q == NULL) {
            s = Lc->next;
            while (s != NULL) {
                if (s->data == p->data)
                    break;
                else
                    s = s->next;
            }
            if (s == NULL) {
                k = (LinkList) malloc(sizeof(LNode));
                k->data = p->data;
                k->next = Lc->next;
                Lc->next = k;
            }
        }
        p = p->next;
    }
}
//二分查找
int binary_search(vector<char>& nums, int target)//返回数据在数组坐标值，不存在返回-1
{
    int right = nums.size() - 1;
    int left = 0;
    int middle = left + (right - left) / 2;
    int number = (int)nums[middle];
    while (number != target) {
        if (number < target) {
            right = middle;
            middle = left + (right - left) / 2;
            number = nums[middle];
        } else if (number > target) {
            left = middle + 1;
            middle = left + (right - left) / 2;
            number = nums[middle];
        }
        if (right == left && number != target)
            return -1;
    }
    return middle;
}
void fun::query() {
    cout << "请输入要查询的元素值：" << endl;
    char temp;
    cin >> temp;
    cout<<"++"<<temp<<endl;
    int key = -1;
    int a1 = -1,a2 = -1;
    if(vt.size() != 0)
        a1 = binary_search(vt, temp);
    if(vt1.size() != 0)
        a2 = binary_search(vt1, temp);
    for(auto it:vt)
        cout<<it<<' ';
    cout<<endl;
    for(auto o:vt1)
        cout<<o<<' ';
    cout<<endl;
    cout<<a1<<' '<<a2<<endl;
    //cout<<(char)a1<<' '<<(char)a2<<endl;
    if (a1 != -1) {
        key = 0;
    }
    if (a2 != -1) {
        key = 1;
    }
    if (a1 != -1 && a2 != -1) {
        key = 2;
    }
    if (a1 == -1 && a2 == -1) {
        key = 3;
    }
    if (key == 0)
        cout << "要查询的元素在集合A中，排第" << a1+1 << "位" << endl;
    else if (key == 1)
        cout << "要查询的元素在集合B中，排第" << a2+1 << "位" << endl;
    else if (key == 2)
        cout << "要查询的元素即在集合A中也在集合B中，在集合A中排第" << a1+1 << "位" << "在集合B中排第" <<
             a2+1 << "位" << endl;
    else if (key == 3)
        cout << "要查询的元素不在集合A也不在集合B，查询失败" << endl;
    cout<<endl<<key;
}

int main() {
    int choice;
    LinkList La, Lb, Lc;
    Init_LinkList(La);
    Init_LinkList(Lb);
    Init_LinkList(Lc);
    while (1) {
        obj.show();
        printf("请输⼊要选择的功能：\n");
        cin >> choice;
        switch (choice) {
            case 1: {
                cout << "请输⼊集合A(⽤空格隔开)" << endl;
                string str, temp;
                getchar();
                getline(cin, str);
                obj.input(La, str, 1);
                printf("请按回⻋继续！\n");
                getchar();
                break;
            }
            case 2: {
                cout << "请输⼊集合B(⽤空格隔开)" << endl;
                string str;
                getchar();
                getline(cin, str);
                obj.input(Lb, str, 2);
                printf("请按回⻋继续！\n");
                getchar();
                break;
            }
            case 3:
                printf("集合A为：\n");
                obj.Output(La);
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            case 4:
                printf("集合B为：\n");
                obj.Output(Lb);
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            case 5:
                printf("集合A与集合B的并集为：\n");
                obj.and_set(La, Lb, Lc);
                obj.Output(Lc);
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            case 6:
                printf("集合A与集合B的交集为：\n");
                obj.intersection(La, Lb, Lc);
                obj.Output(Lc);
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            case 7:
                printf("集合A与集合B的差集为：\n");
                obj.difference_set(La, Lb, Lc);
                obj.Output(Lc);
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            case 8: {
                bool flag = obj.if_exit(La, Lb, 1);
                if (flag)cout << "集合A是集合B的⼦集" << endl;
                else cout << "集合A不是集合B的⼦集" << endl;
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            }
            case 9: {
                bool flag = obj.if_exit(La, Lb, 2);
                if (flag)cout << "集合B是集合A的⼦集" << endl;
                else cout << "集合B不是集合A的⼦集" << endl;
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            }
            case 10:
                obj.query();
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            case 11:
                zxx(La);
                printf("请按回⻋继续！\n");
                getchar();
                getchar();
                break;
            case 0:
                printf("成功退出系统!\n");
                exit(0);
            default:
                printf("输⼊有误!退出系统!\n");
                exit(1);
        }
    }
    return 0;
}