广义表的类定义及其操作的实现

1.头文件

# include <iostream>
using namespace std;
struct GenListNode{        //广义表结点
	int utype;         //结点类型：=0附加头结点；=1原子结点；=2子表结点
	GenListNode *tlink; //尾指针
	union {  //联合体：utype=0，该结点存引用计数ref；=1该结点存值value；=2该结点存子表的头指针
		int ref;
		int value;
		GenListNode *hlink;
	} info;
	GenListNode():utype(0),tlink(NULL){ //结点构造函数
		info.ref=0;
	}
	GenListNode(GenListNode& RL){ //复制构造函数
		utype=RL.utype;
		tlink=RL.tlink;
		switch(utype){    //根据utype的值进行赋值操作
		case'0':info.ref=RL.info.ref; break;
		case'1':info.value=RL.info.value; break;
		case'2':info.hlink=RL.info.hlink; break;
		}
	}
};
struct Items{  //该数据类型用于取表头，表尾函数，不包含tlink，与单链表比较即可理解。
	int utype;
	union{
		int ref;
		int value;
		GenListNode *hlink;
	}info;
	Items():utype(0){     //构造函数
		info.ref=0;
	}
	Items(Items& RL){  //复制构造函数
		utype=RL.utype;
		switch(utype){
		case'0':info.ref=RL.info.ref; break;
		case'1':info.value=RL.info.value; break;
		case'2':info.hlink=RL.info.hlink; break;
		}
	}
};
class GenList{    //广义表类
private:
	GenListNode *first;   //头指针
	GenListNode* Copy(GenListNode *ls); //复制ls指的广义表并返回该表的头指针
	int Length(GenListNode *ls);//求ls指示的广义表的长度
	int Depth(GenListNode *ls); //求ls所指的广义表的深度
	bool Equal(GenListNode *s,GenListNode *t); //判断两个广义表是否相同
	void Remove(GenListNode *ls); //释放ls所指的广义表
	void Createlist(istream& istr,GenListNode *&ls); //根据输入流建立广义表
	void delvalue(GenListNode *ls,int x); //删除广义表中原子结点值为x的结点
public:
	GenList(); //构造函数
	~GenList(); //析构函数
	bool Head(Items& x);  //取表头
	bool Tail(GenList& lt);  //取表尾
	GenListNode* First(); //求第一个元素的地址
	GenListNode* Next(GenListNode *elem); //求elem所指的下一个元素的地址
	void Copy(const GenList& R);  //复制广义表R给调用该函数的广义表
	int Length();  //求调用该函数的广义表的长度
	int Depth();  //求广义表深度
	friend istream& operator>>(istream& istr,GenList& L);  //根据输入流建立广义表
};

2.操作的实现

# include<iostream>
# include<assert.h>
# include"GenList.h"
using namespace std;
GenList::GenList(){  //构造函数，构造一个空表
	first=new GenListNode;
	assert(first!=NULL);
}
bool GenList::Head(Items& x){ //取表头
	if(first->tlink==NULL) return false;
	else{
		x.utype=first->tlink->utype;
		switch(x.utype){
		case'1':x.info.value=first->tlink->info.value; break;
		case'2':x.info.hlink=first->tlink->info.hlink; break;
		}
		return true;
	}
};
bool GenList::Tail(GenList& lt){  //取表尾
	if(first->tlink==NULL) return false;
	else{
		lt.first->utype=0;  //设置附加头结点
		lt.first->info.ref=0;
		lt.first->tlink=Copy(first->tlink->tlink); //调用Copy函数取表尾
		return true;
	}
}
GenListNode* GenList::First(){  //取第一个元素的地址
	if(first->tlink==NULL) return NULL;
	else return first->tlink;
}
GenListNode* GenList::Next(GenListNode *elem){ //取elem下一个结点的地址
	if(elem->tlink==NULL) return NULL;
	else return elem->tlink;
}
void GenList::Copy(const GenList& R){ //把广义表R赋值给调用该函数的广义表
	first=Copy(R.first);//调用了下面的Copy函数
}
GenListNode* GenList::Copy(GenListNode *ls){   //赋值ls所指的广义表并返回副本的头指针
	GenListNode *p=NULL;
	if(ls!=NULL){
		p=new GenListNode; 
		p->utype=ls->utype; //复制表头
		switch(ls->utype){
		case'0':p->info.ref=ls->info.ref; break;
		case'1':p->info.value=ls->info.value; break;
		case'2':p->info.hlink=Copy(ls->info.hlink); break;
		}
	p->tlink=Copy(ls->tlink); //复制表尾
	}
	return p;  //返回头指针
}
int GenList::Length(){  //返回广义表的长度
	return Length(first);
}
int GenList::Length(GenListNode *ls){ //求广义表长度
	if(ls==NULL) return 0;
	else return 1+Length(ls->tlink);//递归求长度
}
int GenList::Depth(){  //返回广义表的深度
	return Depth(first);
}
int GenList::Depth(GenListNode *ls){ //求广义表深度
	if(ls->tlink==NULL)  //空表深度为一
		return 1;
	GenListNode *temp=ls->tlink;
	int m=0,n;
	while(temp!=NULL){  //求子表的最大深度
		if(temp->utype==2){
			n=Depth(temp->info.hlink);
			if(m<n) m=n;
		}
		temp=temp->tlink;
	}
	return m+1; //广义表的深度就是子表的最大深度+1
}
bool GenList::Equal(GenListNode *s,GenListNode *t){  //判断两个广义表是否相等
	int x;
	if(s->tlink==NULL&&t->tlink==NULL) return true;//都为空表，相等
	else if(s->tlink!=NULL&&t->tlink!=NULL&&s->tlink->utype==t->tlink->utype){  //判断表头是否相等
		if(s->tlink->utype==1)
			x=(s->tlink->info.value==t->tlink->info.value)?1:0;
		else if(s->tlink->utype==2)
			x=Equal(s->tlink->info.hlink,t->tlink->info.hlink);
		if(x==1)   //表头相等，接着判断表尾是否相等
			return Equal(s->tlink,t->tlink);
	}
	return false;
}
void GenList::delvalue(GenListNode *ls,int x){  //删除广义表中所有原子值为x的结点
	if(ls->tlink==NULL) return;    //ls为空表
	GenListNode *temp=ls->tlink;
	while(temp!=NULL){
	       while(temp->utype==1){ //如果该点为原子结点，用while因为可能连续几个结点都是原子结点
		         if(temp->info.value==x){ //值为x，删除该结点
			          ls->tlink=temp->tlink;
			          delete temp;
		         }
		   temp=ls->tlink; 
	       }
	       if(temp->utype==2){  //该点为子表结点
		        delvalue(temp->info.hlink,x); //删除子表中所有原子值为x的结点
	            temp=temp->tlink;
		   }
	}
	return ; //删除完毕，返回到主函数
}
GenList::~GenList(){  //析构函数
	Remove(first);
}
void GenList::Remove(GenListNode *ls){ //释放ls指示的广义表
	if(ls->tlink==NULL)  //如果ls为空表，删除附加头结点
		delete ls;
	GenListNode *temp=ls->tlink;
	while(temp!=NULL){
			while(temp!=NULL&&temp->utype==1){ //原子结点
		         ls->tlink=temp->tlink;
		         delete temp;
		         temp=ls->tlink;
	        }
			if(temp->utype==2&&temp!=NULL){ //子表结点
	               Remove(temp->info.hlink); //删除该节点hlink指示的子表
				   ls->tlink=temp->tlink; //删除该结点
				   delete temp;
	               temp=ls->tlink;
			}
	}
	delete ls; //删除附加头结点
	return ; //返回主函数
}

3.阅读建议

（1）由于建立广义表的算法比较复杂，因此本文中并未包括CreateList函数的实现，过几天我再单独写一篇。

（2）本文中基本所有重要函数的实现都用到了递归算法，对对递归不熟悉的小伙伴帮助应该会比较大（包括我）。很多函数只看代码应该不太容易看懂，于是附加一张广义表的结构图，大家可以手动在纸上执行递归的过程：

（3）关于递归过程中创建局部变量的问题，跟大家分享一个百度知道的问题，相信对大家理解递归有帮助：（在此处谢谢答主）

问题：当函数发生递归调用时,同一个局部变量在不同程度上可以同时存在不同的取值,这在底层是如何做到的? 

解答：

你在源代码中看到的一个局部变量，其实在函数递归过程中是存在很多副本的。


比如，你在源代码中看到一个一个局部变量 a
其实在函数递归掉用的时候，每调用一次都会在所调用函数的运行空间里存储一个a的，所以其实存在很多很多的不同的a，他们各自的存储空间是不一样的，当然能存储不同的取值了。


如
开始调用t(),先为t()分配存储空间，存储空里有一个a
然后t()调用t()（我们称之为t1()），先为t1()分配存储空间，存储空间里有存一个a（与前面的a是不同的）
t1()又调用t()（我们称之为t2()），先为t2分配存储空间，存储空间里存一个a（又是一个不同的a)
.....................以此类推


所以，并不是“同一个局部变量在不同程度上可以同时存在不同的取值” 
而是“不同的局部变量在不同的函数空间里存储了不同的值”