广义表的实现（用类实现，包含构造函数，析构函数，遍历函数等）

1、在实现广义表之前做一个约定，如果一个广义表为空表，那么头指针也会指向一个表示广义表的节点，但是这个节点的头部跟尾部都是NULL。

2、由前面的约定可以得出，如果广义表的元素含有空表，那么指向这个元素的表头指针不为空，而是指向一个TAG为1 ，HP与RP都为NULL的节点。

3、为了减少复杂度，实现的广义表不好含递归自己的情况，也不包含共享元素的情况。

#include <iostream>
#include <string>


using namespace std;


struct Node {
int tag;
union{
int data;
struct {
Node * hp;
Node * rp;
} ptr;
};
};
class GList{
public:
GList();
~GList();
public:
int Deep(Node * p);
int Long(Node * p);
void Traverse(Node * p);
Node * first;
private:
void create(Node * &p);
void utility(Node * p);


};
GList::GList()
{
cout<<"请初始化广义表，1为本层数据，0为本层结束输入，-1为进入下一层。\n";
create(first);
}
void GList::create(Node* &p)
{
p=new Node;
p->tag=1;
Node * q=p,*qre=q;
int cmd,data;
while(1)
{
do{
cin>>cmd;
if(cmd==1)
{
cin>>data;
Node * t=new Node;
t->tag=0;
t->data=data;
q->ptr.hp=t;
qre=q;
t=new Node;t->tag=1;
q->ptr.rp=t;q=t;
}
}while(cmd==1);
if(cmd==0)
{
if(qre!=q)
{
qre->ptr.rp=NULL;
delete q;return;
}
else
{
q->ptr.hp=q->ptr.rp=NULL;
return;
}
}
if(cmd==-1)
{
create(q->ptr.hp);
Node * t=new Node;
qre=q;
t->tag=1;
q->ptr.rp=t;q=t;
}
}
}
GList::~GList()
{
cout<<"系统调用析构函数...\n";
utility(first);
}
void  GList::utility(Node * p)
{
if(p==NULL)
return;
do{
if(p->ptr.hp&&p->ptr.hp->tag==0)
{
delete p->ptr.hp;
}
else
{
utility(p->ptr.hp);
}
Node* temp=p;
p=p->ptr.rp;
delete temp;
}while(p);
}
int GList::Deep(Node * p)
{
if(p==NULL) throw "Error,ILEGEL ARGUMENT.";
int max=0;int t;
do{
if(p->ptr.hp&&p->ptr.hp->tag==1)
{
t=Deep(p->ptr.hp);
if(t>max) max=t;
}
p=p->ptr.rp;
}while(p);
return max+1;
}
int GList::Long(Node * p)
{
int cnt=0;
while(p&&p->ptr.hp)
{
cnt++;
p=p->ptr.rp;
}
return cnt;
}
void GList::Traverse(Node * p)
{
while(p&&p->ptr.hp)
{
if(p->ptr.hp->tag==0)
cout<<p->ptr.hp->data<<" ";
else
Traverse(p->ptr.hp);
p=p->ptr.rp;
}
}
void main()
{
GList object;
cout<<"深度为："<<object.Deep(object.first)<<endl;
cout<<"长度为："<<object.Long(object.first)<<endl;
object.Traverse(object.first);
::system("pause");
}

输入测试：

不含空表情况 

包含空表情况