GeneralList-广义表

广义表是非线性的结构,是线性表的一种扩展,是有n个元素组成有限序列。

广义表的定义是递归的,因为在表的描述中又得到了表,允许表中有表。

    

<1> A = ()

<2> B = (a,b)

<3> C = (a,b,(c,d))

<4> D = (a,b,(c,d),(e,(f),h)) 

<5> E = (((),()))

wKiom1cbEmGR0aqXAABZ15K4Nig070.png


#define _CRT_SECURE_NO_WARNINGS 1


#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>

#include <assert.h>

using namespace std;


enum Type

{

HEAD,

VALUE,

SUB

};


struct GeneralizedNode

{

Type _type;//类型

GeneralizedNode* _next;//指向同层下一个结点


union

{

//int _value;

char _value;

GeneralizedNode* _subLink;//指向子表的指针

};


GeneralizedNode(Type type = VALUE, const int value = 0)

:_type(type)

,_next(NULL)

,_value(value)

{}

};


class Generalized

{

public:

Generalized()

:_head(NULL)

{}


Generalized(const char* str)

:_head(NULL)

{

_head = _CreateList(str);

}


void Print() const

{

_Print(_head);

cout<<endl;

}


size_t Size() const

{

return _Size(_head);

}


size_t Depth() const

{

return _Depth(_head);

}


    //===========新加的

    Generalized(const Generalized& g);

    Generalized& operator=(Generalized g);    //  现代写法

    ~Generalized();


protected:

GeneralizedNode* _CreateList(const char*& str);

void _Print(GeneralizedNode* head) const;

bool _IsValue(char ch);

size_t  _Size(GeneralizedNode* head) const;

size_t _Depth(GeneralizedNode* head) const;

    GeneralizedNode* _Copy(const GeneralizedNode* head);

    void _Destory(GeneralizedNode* head);


protected:

GeneralizedNode* _head;

};


bool Generalized:: _IsValue(char ch)

{

if ((ch >= '0' && ch <= '9')

|| (ch >= 'a' && ch <= 'z')

|| (ch >= 'A' && ch <= 'Z'))

{

return true;

}

else

{

return false;

}

}


GeneralizedNode* Generalized::_CreateList(const char*& str)//注意&

{

assert(str);


assert(*str == '(');

// D = (a,b,(c,d),(e,(f),h))


GeneralizedNode* head = new GeneralizedNode(HEAD);

GeneralizedNode* cur = head;

++str;

while (*str != '\0')

{

if (*str == '(')// 有子层

{

cur->_next = new GeneralizedNode(SUB);

cur = cur->_next;

cur->_subLink = _CreateList(str);//下一层

}

else if(_IsValue(*str))

{

cur->_next = new GeneralizedNode(VALUE, *str);

cur = cur->_next;

++str;

}

else if (*str == ')')

{

++str;// **********更新上一层的str

break;

}

else // 其他情况 *str为 逗号 空格 制表符 等

{

++str;

}

}


return head;

}



void Generalized::_Print(GeneralizedNode* head)const

{

assert(head && head->_type == HEAD);

GeneralizedNode* cur = head->_next;

cout<<"(";

while(cur)

{

if (cur->_type == VALUE)

{

cout<<cur->_value;

cur = cur->_next;

if (cur != NULL)

{

cout<<",";

}

}

else if (cur->_type == SUB)

{

_Print(cur->_subLink);

cur = cur->_next;

if (cur != NULL)

{

cout<<",";

}

}

}

cout<<")";

}


size_t  Generalized::_Size(GeneralizedNode* head) const

{

assert(head && head->_type == HEAD);

GeneralizedNode* cur = head->_next;

size_t count = 0;

while(cur)

{

if (cur->_type == VALUE)

{

count++;

}

else if(cur->_type == SUB)

{

count += _Size(cur->_subLink);

}


cur = cur->_next;

}


return count;

}


// 有问题

//size_t Generalized::_Depth(GeneralizedNode* head) const

//{

//assert(head && head->_type == HEAD);

//GeneralizedNode* cur = head->_next;

//size_t depth = 1;

//while(cur)

//{

//if (cur->_type == SUB)

//{

//depth += _Depth(cur->_subLink);

//}

//

//cur = cur->_next;

//}

//

//return depth;

//}


size_t Generalized::_Depth(GeneralizedNode* head) const

{

    assert(head && head->_type == HEAD);

    GeneralizedNode* cur = head->_next;

    size_t depth = 1;

    while (cur)

    {

        if (cur->_type == SUB)

        {

            size_t SubDepth = _Depth(cur->_subLink);

            if (depth < 1 + SubDepth)   //  找最大的 depth      注意 不要用 depth = depth + SubDepth

            {

                depth = 1 + SubDepth;

            }

        }


        cur = cur->_next;

    }

    return depth;

}


Generalized:: Generalized(const Generalized& g)

{

    _head = _Copy(g._head);

}


GeneralizedNode* Generalized::_Copy(const GeneralizedNode* head)

{

    assert(head && head->_type == HEAD);


    const GeneralizedNode* cur =  head->_next;

    GeneralizedNode* retHead = new GeneralizedNode(HEAD);

    GeneralizedNode* newNode = retHead;


    while (cur)

    {

        if (cur->_type == VALUE)

        {

            newNode->_next = new GeneralizedNode(VALUE, cur->_value);

            newNode = newNode->_next;

        }

        else if (cur->_type == SUB)

        {

               newNode->_next = new GeneralizedNode(SUB);

               newNode = newNode->_next;

               newNode->_subLink = _Copy(cur->_subLink);

        }


        cur = cur->_next;

    }


    return retHead;

}



Generalized& Generalized::operator=(Generalized g)    //  现代写法

{

    swap(_head, g._head);

    return *this;

}


Generalized::~Generalized()

{

    _Destroy(_head);

}

 

void Generalized::_Destory(GeneralizedNode* head)

{

    GeneralizedNode* cur = head;

    while (cur)

    {

        GeneralizedNode* del = cur;

        cur = cur->_next;

        if (del->_type == SUB)

        {

            _Destory(del->_subLink);

        }

        delete del;

        del = NULL;

    }

}


void test_G_chuangjian()

{

char* str = "(a,b,(c,d))";

Generalized g(str);


g.Print();


cout<<g.Size()<<endl;

cout<<g.Depth()<<endl;


    cout<<"============"<<endl;


    char* str2 = "(a,b,(c,d),(e,(f),h))";

Generalized g2(str2);


g2.Print();


cout<<g2.Size()<<endl;

cout<<g2.Depth()<<endl;


    cout<<"============"<<endl;


Generalized g3(g2);


g3.Print();


cout<<g3.Size()<<endl;

cout<<g3.Depth()<<endl;


      cout<<"============"<<endl;


Generalized g4;

    g4 = g2;


g4.Print();


cout<<g4.Size()<<endl;

cout<<g4.Depth()<<endl;

}


int main()

{

test_G_chuangjian();


return 0;

}