广义表的实现

#pragma once
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

template <class T>
struct GenListNode;

template <class T>
struct Item {    //广义表结点的值项
    int utype;
    union {
        int ref = 0;
        T value;
        GenListNode<T> * hlink;

    }info;
    Item() : utype(0) {}
    Item(const Item & other) {
        utype = other.utype;
        info = other.info;
    }
};

template <class T>
struct GenListNode {
    Item<T> item;
    GenListNode<T> * tlink;
    GenListNode() : item(), tlink(nullptr) {}
    GenListNode(const GenListNode<T> & other) : item(other.item), tlink(other.tlink) {}
};

template <class T>
class GenList {
private:
    //成员域
    GenListNode<T> * first;
public:
    //构造方法
    GenList();
    GenList(const GenList<T> & other);
    ~GenList();
    //成员方法
    bool getHead(Item<T> & x); //获取第一个元素的值域
    bool getTail(GenList<T> & subList); //获取表尾
    GenListNode<T> * head();   //返回第一个元素
    GenListNode<T> * Next(GenListNode<T> * cur); //返回当前元素的下一个元素
    int lenth(); //返回广义表的长度
    int depth(); //返回广义表的深度
    GenList<T> & operator = (const GenList<T> & other); //广义表复制
    bool operator == (const GenList<T> & other); //比较广义表是否相等
    void input();   //输入
    void output();  //输出
private:
    //工具函数
    void remove(GenListNode<T> * Is);
    GenListNode<T> * copy(GenListNode<T> * Is, vector<GenListNode<T> *> &mv, vector<GenListNode<T> *> &ov);
    int lenth(GenListNode<T> * Is);
    int depth(GenListNode<T> * Is, vector<GenListNode<T> *>& v);
    bool equal(GenListNode<T> * s, GenListNode<T> * t, vector<GenListNode<T> *>& v1, vector<GenListNode<T> *>& v2);
    void input(GenListNode<T> * &Is, vector<char> & v1, vector<GenListNode<T> *> & v2); //创建Is指向的广义表
    void output(GenListNode<T> * Is, vector<char> & v1, vector<GenListNode<T> *> & v2, char & c); //输出由Is指向的广义表
};

template<class T>
inline GenList<T>::GenList()
{
    first = new GenListNode<T>();
}

template<class T>
inline GenList<T>::GenList(const GenList<T>& other)
{
    vector<GenListNode<T> *> v1, v2;
    first = copy(other.first, v1, v2);
}

template<class T>
inline GenList<T>::~GenList()
{
    remove(first);
}

template<class T>
inline bool GenList<T>::getHead(Item<T>& x)
{
    if (first->tlink == nullptr)
        return false;
    x = first->tlink->item;
    return true;
}

template<class T>
inline bool GenList<T>::getTail(GenList<T>& subList)
{
    if (first->tlink == nullptr)
        return false;
    remove(subList.first);
    vector<GenListNode<T> *> v1, v2;
    subList.first = new GenListNode<T>();
    subList.first->tlink = copy(first->tlink->tlink, v1, v2);
    return true;
}

template<class T>
inline GenListNode<T>* GenList<T>::head()
{
    return first->tlink;
}

template<class T>
inline GenListNode<T>* GenList<T>::Next(GenListNode<T>* cur)
{
    return cur->tlink;
}

template<class T>
inline int GenList<T>::lenth()
{
    return lenth(first);
}

template<class T>
inline int GenList<T>::depth()
{
    vector<GenListNode<T> *> v;
    return depth(first, v);
}

template<class T>
inline GenList<T>& GenList<T>::operator=(const GenList<T>& other)
{
    vector<GenListNode<T> *> v1, v2;
    remove(first);
    first = copy(other.first, v1, v2);
    return *this;
}

template<class T>
inline bool GenList<T>::operator==(const GenList<T>& other)
{
    vector<GenListNode<T> *> v1, v2;
    return equal(first, other.first, v1, v2);
}

template<class T>
inline void GenList<T>::input()
{
    remove(first);
    first = nullptr;
    vector<char> v1;
    vector<GenListNode<T> *> v2;
    input(first, v1, v2);
}

template<class T>
inline void GenList<T>::output()
{
    char c = 64;
    vector<char> v1;
    vector<GenListNode<T> *> v2;
    output(first, v1, v2, c);
}

template<class T>
inline void GenList<T>::remove(GenListNode<T>* Is)
{
    while (Is != nullptr) {
        GenListNode<T> * del = Is;
        Is = Is->tlink;
        if ((del->item.utype == 0 && del->item.info.ref == 0)
            || del->item.utype == 1)
            delete del;
        else if (del->item.utype == 0 && del->item.info.ref > 0)
            del->tlink = nullptr;
        else if(del->item.utype == 2){
            --del->item.info.hlink->item.info.ref;
            remove(del->item.info.hlink);
            delete del;
        }
    }
}

template<class T>
inline GenListNode<T>* GenList<T>::copy(GenListNode<T>* Is, vector<GenListNode<T> *> &mv, vector<GenListNode<T> *> &ov)
{
    //特殊处理
    if (Is == nullptr)
        return nullptr;
    auto i = find(ov.begin(), ov.end(), Is);
    if (i != ov.end()) {  //已经复制
        return mv.at(i - ov.begin());
    }
    else {  //未复制
        GenListNode<T> * It = new GenListNode<T>(*Is); //复制附加头结点
        //存放附加头节点信息
        mv.push_back(It);
        ov.push_back(Is);
        //复制同一层结点
        Is = Is->tlink;
        GenListNode<T> *cur = It;
        while (Is != nullptr) {
            //复制Is指向结点（并插入cur后)
            cur->tlink = new GenListNode<T>(*Is);
            if (Is->item.utype == 2) {
                cur->tlink->item.info.hlink = copy(Is->item.info.hlink, mv, ov);
            }
            //更新
            cur = cur->tlink;
            Is = Is->tlink;
        }
        return It;
    }
}

template<class T>
inline int GenList<T>::lenth(GenListNode<T>* Is)
{
    if (Is == nullptr)
        return -1;
    return lenth(Is->tlink) + 1;
}


template<class T>
inline int GenList<T>::depth(GenListNode<T>* Is, vector<GenListNode<T> *>& v)
{
    //求表中结点的最大深度
    int max = 0;
    while (Is != nullptr) {  //遍历每一个结点
        if (Is->item.utype == 2) {
            //异常情况
            auto i = find(v.begin(), v.end(), Is);
            if (i != v.end()) {
                cerr << "该表无法求深度";
                system("pause");
                exit(1);
            }
            v.push_back(Is);
            int temp = depth(Is->item.info.hlink, v);
            if (temp > max)
                max = temp;
        }
        Is = Is->tlink;
    }
    return max + 1;
}

template<class T>
inline bool GenList<T>::equal(GenListNode<T>* s, GenListNode<T>* t, vector<GenListNode<T> *>& v1, vector<GenListNode<T> *>& v2)
{
    if (s == nullptr || t == nullptr) {
        if (s == t)
            return true;
    }
    else if (s->item.utype == t->item.utype) {
        if (s->item.utype == 0) {
            if(s->item.info.ref == t->item.info.ref){
                v1.push_back(s);
                v2.push_back(t);
                return equal(s->tlink, t->tlink, v1, v2);
            }
        }
        else if (s->item.utype == 1) {
            if (s->item.info.value == t->item.info.value)
                return equal(s->tlink, t->tlink, v1, v2);
        }
        else {
            auto i = find(v1.begin(), v1.end(), s->item.info.hlink);
            auto j = find(v2.begin(), v2.end(), t->item.info.hlink);
            if (i == v1.end() && j == v2.end()) {
                return equal(s->item.info.hlink, t->item.info.hlink, v1, v2);
                return equal(s->tlink, t->tlink, v1, v2);
            }
            else if(i-v1.begin() == j-v2.begin()){
                return equal(s->tlink, t->tlink, v1, v2);
            }
        }
    }
    return false;
}


template<class T>
inline void GenList<T>::input(GenListNode<T>*& Is, vector<char>& v1, vector<GenListNode<T>*>& v2)
{
    T chr;
    cin >> chr;
    //特殊情况
    if (first == nullptr) {
        //异常处理
        if (chr != '(' && !(isalpha(chr) && isupper(chr))) {
            cerr << "错误";
            system("pause");
            exit(1);
        }
        Is = new GenListNode<T>();
        if (isalpha(chr) && isupper(chr)) {
            v1.push_back(chr);
            v2.push_back(Is);
            cin >> chr;
            //异常处理
            if (chr != '(') {
                cerr << "错误";
                system("pause");
                exit(1);
            }
        }
        input(Is->tlink, v1, v2);
        return;
    }
    else if ((isalpha(chr) && isupper(chr)) || chr == '(') {
        //创建2类结点
        Is = new GenListNode<T>();
        Is->item.utype = 2;;
        if (isalpha(chr) && isupper(chr)) { //A()
            auto i = find(v1.begin(), v1.end(), chr);
            if (i == v1.end()) { //还没有创建过该子表
                Is->item.info.hlink = new GenListNode<T>();
                ++Is->item.info.hlink->item.info.ref;
                v1.push_back(chr);
                v2.push_back(Is->item.info.hlink);
                cin >> chr;
                if (chr != '(') {
                    cerr << "错误";
                    system("pause");
                    exit(1);
                }
                input(Is->item.info.hlink->tlink, v1, v2);
                input(Is->tlink, v1, v2);
            }
            else {  //创建过了
                GenListNode<T> * sub = v2[i - v1.begin()];
                ++sub->item.info.ref;
                Is->item.info.hlink = sub;
                //异常处理
                if (cin.peek() != ')' && cin.peek() != ',') {
                    cerr << "错误";
                    system("pause");
                    exit(1);
                }
                input(Is->tlink, v1, v2);
            }
        }
        else { //( )
            //创建子广义表的附加头结点
            Is->item.info.hlink = new GenListNode<T>();
            ++Is->item.info.hlink->item.info.ref;
            input(Is->item.info.hlink->tlink, v1, v2);
            input(Is->tlink, v1, v2);
        }
    }
    else if (isalpha(chr) && islower(chr)) {
        //创建1类结点
        Is = new GenListNode<T>();
        Is->item.utype = 1;
        Is->item.info.value = chr;
        input(Is->tlink, v1, v2);
    }
    else if (chr == ',')
        input(Is, v1, v2);
}

template<class T>
inline void GenList<T>::output(GenListNode<T>* Is, vector<char> & v1, vector<GenListNode<T>*> & v2, char & c)
{
    //边界
    if (Is == nullptr)
        cout << ')';
    else if (Is->item.utype == 0) {  //类型0结点
        auto i = find(v2.begin(), v2.end(), Is);
        if (i == v2.end()) { //没有输出过该子表
            ++c;
            cout << c << '(';
            v1.push_back(c);
            v2.push_back(Is);
            output(Is->tlink, v1, v2, c);
        }
        else {  //输出过该子表
            cout << v1.at(i - v2.begin());
        }
    }
    else if (Is->item.utype == 1) { //类型1结点
        cout << Is->item.info.value;
        if (Is->tlink != nullptr)
            cout << ", ";
        output(Is->tlink, v1, v2, c);
    }
    else {   //类型2结点
        output(Is->item.info.hlink, v1, v2, c);
        if (Is->tlink != nullptr)
            cout << ", ";
        output(Is->tlink, v1, v2, c);
    }
}