数据结构-广义表（GeneralizedList）实现

广义表

广义表是非线性的数据结构，是线性表的一种推广，由N个序列组成的有序序列；
广义表在表的描述中又得到了表，即允许表中有表，简而言之，广义表的定义是递归的。
广义表的简单表示：
(1)A=();
(2)B=(a,b);
(3)C=(c,(a,b));
(4)D=(d,(c,(a,b)));
示意图：



代码实现：

//GeneralizedList.h
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;

enum Type
{
HEAD_TYPE,
VALUE_TYPE,
SUB_TYPE,
};

struct GeneralizedNode
{
Type _type;
GeneralizedNode* _next;

union
{
char _value;
GeneralizedNode* _subLink;
};

GeneralizedNode(Type type = HEAD_TYPE, char value = 0)
:_type(type)
,_next(NULL)
{
if (_type == VALUE_TYPE)
{
_value = value;
}
else if (_type == SUB_TYPE)
{
_subLink = NULL;
}
}
};

class Generalized
{
typedef GeneralizedNode Node;
public:
Generalized()
:_head(new Node(HEAD_TYPE))
{}

Generalized(const char* str)
{
_head = _CreateLized(str);
}

Generalized(const Generalized& g)
{
_head = _Copy(g._head);
}

//赋值运算符重载函数现代写法
Generalized& operator= (Generalized g)
{
swap(this->_head, g._head);
return *this;
}

~Generalized()
{
_Destory(_head);
_head = NULL;
}

//打印广义表
void Print()
{
_Print(_head);
cout<<endl;
}

//求广义表元素个数
size_t Size()
{
return _Size(_head);
}

//求广义表深度
size_t Depth()
{
return _Depth(_head);
}

protected:
//对已有广义表复制，便于实现拷贝构造函数和赋值运算符重载函数
Node* _Copy(Node* head)
{
Node* newHead = new Node(HEAD_TYPE);
assert(head->_type == HEAD_TYPE);

Node* cur = head->_next;
Node* newCur = newHead;

while (cur)
{
if (cur->_type == VALUE_TYPE)
{
newCur->_next = new Node(VALUE_TYPE, cur->_value);
newCur = newCur->_next;
}
else if (cur->_type == SUB_TYPE)
{
newCur->_next = new Node(SUB_TYPE);
newCur = newCur->_next;

newCur->_subLink = _Copy(cur->_subLink);
}

cur = cur->_next;
}

return newHead;
}

//对广义表销毁，便于完成析构函数
void _Destory(Node* head)
{
Node* cur = head;
while (cur)
{
Node*del = cur;
cur = cur->_next;

if (del->_type == SUB_TYPE)
{
_Destory(del->_subLink);
}

delete del;
}
}

bool _IsValue(char ch)
{
if ((ch >= '0' && ch <= '9')
|| (ch >= 'a' && ch <= 'z')
|| (ch >= 'A' && ch <= 'Z'))
{
return true;
}
else
{
return false;
}
}

//创建广义表（递归实现）
Node* _CreateLized(const char* & str)
{
assert(str && *str == '(');
++str;
Node* head = new Node(HEAD_TYPE);
Node* cur = head;

while (*str)
{
if (_IsValue(*str))
{
cur->_next = new Node(VALUE_TYPE, *str);
cur = cur->_next;
++str;
}
else if (*str == '(')
{
cur->_next = new Node(SUB_TYPE);
cur = cur->_next;
cur->_subLink = _CreateLized(str);
}
else if (*str == ')')
{
++str;
return head;
}
else
{
++str;
}
}

assert(false);
return head;
}

void _Print( Node* head)
{
Node* cur = head;
while(cur)
{
if (cur->_type == HEAD_TYPE)
{
cout<<"(";
}
else if (cur->_type == VALUE_TYPE)
{
cout<<cur->_value;
if (cur->_next)
{
cout<<",";
}
}
else
{
_Print(cur->_subLink);
if (cur->_next)
{
cout<<",";
}
}

cur = cur->_next;
}

cout<<")";
}

size_t _Size(Node* head)
{
size_t size = 0;
Node* cur = head;
while (cur)
{
if (cur->_type == VALUE_TYPE)
{
++size;
}
else if (cur->_type == SUB_TYPE)
{
size += _Size(cur->_subLink);
}

cur = cur->_next;
}

return size;
}

size_t _Depth(Node* head)
{
int depth = 1;
Node* cur = head;
while (cur)
{
if (cur->_type == SUB_TYPE)
{
int subDepth = _Depth(cur->_subLink);
if (subDepth+1 > depth)
{
depth = subDepth+1;
}
}

cur = cur->_next;
}

return depth;
}
protected:
Node* _head;
};
//test.cpp
#include "GeneralizedList.h"
void test()
{
//Generalized g1("(a,b,(c,d),(e,(f),h))");
Generalized g1("(a,b,(c,d))");
cout<<"g1:";
g1.Print();
cout<<"g1 Of Size Is:"<<g1.Size()<<endl;
cout<<"g1 Of Depth Is:"<<g1.Depth()<<endl;

Generalized g2("(a,b,(c,d),(e,(f),h))");
cout<<"g2:";
g2.Print();
cout<<"g2 Of Size Is:"<<g2.Size()<<endl;
cout<<"g2 Of Depth Is:"<<g2.Depth()<<endl;

Generalized g3(g2);
cout<<"g3:";
g3.Print();
g2=g1;
cout<<"g2:";
g2.Print();
}

int main()
{
test();
getchar();
return 0;
}