廣義表的存儲結構（廣義表的遞歸算法，複製廣義表，求廣義表的深度）

// c5-5.h 廣義表的頭尾鏈表存儲結構(見圖5.16)
enum ElemTag{ATOM,LIST}; // ATOM==0：原子，LIST==1：子表
typedef struct GLNode
{
	ElemTag tag; // 公共部分，用於區分原子結點和表結點
	union // 原子結點和表結點的聯合部分
	{
		AtomType atom; // atom是原子結點的值域，AtomType由用戶定義
		struct
		{
			GLNode *hp,*tp;
		}ptr; // ptr是表結點的指針域，prt.hp和ptr.tp分別指向表頭和表尾
	};
}*GList,GLNode; // 廣義表類型

圖517 是根據c5-5.h 定義的廣義表(a,(b,c,d))的存儲結構。它的長度爲2，第1
個元素爲原子a，第2 個元素爲子表(b,c,d)。

// c5-6.h 廣義表的擴展線性鏈表存儲表示(見圖5.18)
enum ElemTag{ATOM,LIST};
// ATOM==0：原子，LIST==1：子表
typedef struct GLNode1
{
	ElemTag tag; // 公共部分，用於區分原子結點和表結點
	union // 原子結點和表結點的聯合部分
	{
		AtomType atom; // 原子結點的值域
		GLNode1 *hp; // 表結點的表頭指針
	};
	GLNode1 *tp; // 相當於線性鏈表的next，指向下一個元素結點
}*GList1,GLNode1; // 廣義表類型GList1是一種擴展的線性鏈表

爲了和c5-5.h 定義的存儲結構相區別，令c5-6.h 定義的結構類型名爲GList1 和
GLNode1。
圖519 是根據c5-6.h 定義的廣義表(a,(b,c,d))的擴展線性鏈表存儲結構。在這種
結構中，廣義表的頭指針所指結點的tag 域值總是1(表)，其tp 域總是NULL。這樣看
來，廣義表的頭指針所指結點相當於表的頭結點。和圖517 相比，圖519 這種結構更
簡潔些。

廣義表的遞歸算法

求廣義表的深度
算法5.5 在bo5-5.cpp 中。

複製廣義表

算法5.6 在bo5-5.cpp 中。

// func5-1.cpp 廣義表的書寫形式串爲SString類型，包括算法5.8。bo5-5.cpp和bo5-6.cpp調用
#include"c4-1.h" // 定義SString類型
#include"bo4-1.cpp" // SString類型的基本操作
void sever(SString str,SString hstr) // 算法5.8改。SString是數組，不需引用類型
{ // 將非空串str分割成兩部分：hstr爲第一個′,′之前的子串，str爲之後的子串
	int n,k,i; // k記尚未配對的左括號個數
	SString ch,c1,c2,c3;
	n=StrLength(str); // n爲串str的長度
	StrAssign(c1,","); // c1=′,′
	StrAssign(c2,"("); // c2=′(′
	StrAssign(c3,")"); // c3=′)′
	SubString(ch,str,1,1); // ch爲串str的第1個字符
	for(i=1,k=0;i<=n&&StrCompare(ch,c1)||k!=0;++i) // i小於串長且ch不是’,’
	{ // 搜索最外層的第一個逗號
		SubString(ch,str,i,1); // ch爲串str的第i個字符
		if(!StrCompare(ch,c2)) // ch=′(′
			++k; // 左括號個數+1
		else if(!StrCompare(ch,c3)) // ch=′)′
			--k; // 左括號個數-1
	}
	if(i<=n) // 串str中存在′,′，它是第i-1個字符
	{
		SubString(hstr,str,1,i-2); // hstr返回串str′,′前的字符
		SubString(str,str,i,n-i+1); // str返回串str′,′後的字符
	}
	else // 串str中不存在′,′
	{
		StrCopy(hstr,str); // 串hstr就是串str
		ClearString(str); // ′,′後面是空串
	}
}

// bo5-5.cpp 廣義表的頭尾鏈表存儲(存儲結構由c5-5.h定義)的基本操作(11個),包括算法5.5,5.6,5.7
#include"func5-1.cpp" // 算法5.8
void InitGList(GList &L)
{ // 創建空的廣義表L
	L=NULL;
}
void CreateGList(GList &L,SString S) // 算法5.7
{ // 採用頭尾鏈表存儲結構，由廣義表的書寫形式串S創建廣義表L。設emp="()"
	SString sub,hsub,emp;
	GList p,q;
	StrAssign(emp,"()"); // 空串emp="()"
	if(!StrCompare(S,emp)) // S="()"
		L=NULL; // 創建空表
	else // S不是空串
	{
		if(!(L=(GList)malloc(sizeof(GLNode)))) // 建表結點
			exit(OVERFLOW);
		if(StrLength(S)==1) // S爲單原子，只會出現在遞歸調用中
		{
			L->tag=ATOM;
			L->atom=S[1]; // 創建單原子廣義表
		}
		else // S爲表
		{
			L->tag=LIST;
			p=L;
			SubString(sub,S,2,StrLength(S)-2); // 脫外層括號(去掉第1個字符和最後1個字符)給串sub
			do
			{ // 重複建n個子表
				sever(sub,hsub); // 從sub中分離出表頭串hsub
				CreateGList(p->ptr.hp,hsub);
				q=p;
				if(!StrEmpty(sub)) // 表尾不空
				{
					if(!(p=(GLNode *)malloc(sizeof(GLNode))))
						exit(OVERFLOW);
					p->tag=LIST;
					q->ptr.tp=p;
				}
			}while(!StrEmpty(sub));
			q->ptr.tp=NULL;
		}
	}
}
void DestroyGList(GList &L)
{ // 銷燬廣義表L
	GList q1,q2;
	if(L)
	{
		if(L->tag==LIST) // 刪除表結點
		{
			q1=L->ptr.hp; // q1指向表頭
			q2=L->ptr.tp; // q2指向表尾
			DestroyGList(q1); // 銷燬表頭
			DestroyGList(q2); // 銷燬表尾
		}
		free(L);
		L=NULL;
	}
}
void CopyGList(GList &T,GList L)
{ // 採用頭尾鏈表存儲結構，由廣義表L複製得到廣義表T。算法5.6
	if(!L) // 複製空表
		T=NULL;
	else
	{
		T=(GList)malloc(sizeof(GLNode)); // 建表結點
		if(!T)
			exit(OVERFLOW);
		T->tag=L->tag;
		if(L->tag==ATOM)
			T->atom=L->atom; // 複製單原子
		else
		{
			CopyGList(T->ptr.hp,L->ptr.hp); // 遞歸複製子表
			CopyGList(T->ptr.tp,L->ptr.tp);
		}
	}
}
int GListLength(GList L)
{ // 返回廣義表的長度，即元素個數
	int len=0;
	while(L)
	{
		L=L->ptr.tp;
		len++;
	}
	return len;
}
int GListDepth(GList L)
{ // 採用頭尾鏈表存儲結構，求廣義表L的深度。算法5.5
	int max,dep;
	GList pp;
	if(!L)
		return 1; // 空表深度爲1
	if(L->tag==ATOM)
		return 0; // 原子深度爲0，只會出現在遞歸調用中
	for(max=0,pp=L;pp;pp=pp->ptr.tp)
	{
		dep=GListDepth(pp->ptr.hp); // 遞歸求以pp->ptr.hp爲頭指針的子表深度
		if(dep>max)
			max=dep;
	}
	return max+1; // 非空表的深度是各元素的深度的最大值加1
}
Status GListEmpty(GList L)
{ // 判定廣義表是否爲空
	if(!L)
		return TRUE;
	else
		return FALSE;
}
GList GetHead(GList L)
{ // 生成廣義表L的表頭元素，返回指向這個元素的指針
	GList h,p;
	if(!L) // 空表無表頭
		return NULL;
	p=L->ptr.hp; // p指向L的表頭元素
	CopyGList(h,p); // 將表頭元素複製給h
	return h;
}
GList GetTail(GList L)
{ // 將廣義表L的表尾生成爲廣義表，返回指向這個新廣義表的指針
	GList t;
	if(!L) // 空表無表尾
		return NULL;
	CopyGList(t,L->ptr.tp); // 將L的表尾拷給t
	return t;
}
void InsertFirst_GL(GList &L,GList e)
{ // 初始條件：廣義表存在。操作結果：插入元素e(也可能是子表)作爲廣義表L的第1元素(表頭)
	GList p=(GList)malloc(sizeof(GLNode)); // 生成新結點
	if(!p)
		exit(OVERFLOW);
	p->tag=LIST; // 結點的類型是表
	p->ptr.hp=e; // 表頭指向e
	p->ptr.tp=L; // 表尾指向原表L
	L=p; // L指向新結點
}
void DeleteFirst_GL(GList &L,GList &e)
{ // 初始條件：廣義表L存在。操作結果：刪除廣義表L的第一元素，並用e返回其值
	GList p=L; // p指向第1個結點
	e=L->ptr.hp; // e指向L的表頭
	L=L->ptr.tp; // L指向原L的表尾
	free(p); // 釋放第1個結點
}
void Traverse_GL(GList L,void(*v)(AtomType))
{ // 利用遞歸算法遍歷廣義表L
	if(L) // L不空
		if(L->tag==ATOM) // L爲單原子
			v(L->atom);
		else // L爲廣義表
		{
			Traverse_GL(L->ptr.hp,v); // 遞歸遍歷L的表頭
			Traverse_GL(L->ptr.tp,v); // 遞歸遍歷L的表尾
		}
}

// main5-5.cpp 檢驗bo5-5.cpp的主程序
#include"c1.h"
typedef char AtomType; // 定義原子類型爲字符型
#include"c5-5.h" // 定義廣義表的頭尾鏈表存儲
#include"bo5-5.cpp"
void visit(AtomType e)
{
	printf("%c ", e);
}
void main()
{
	char p[80];
	SString t;
	GList l,m;
	InitGList(l);
	InitGList(m);
	printf("空廣義表l的深度=%d l是否空？%d(1:是0:否)\n",GListDepth(l),GListEmpty(l));
	printf("請輸入廣義表l(書寫形式：空表:(),單原子:(a),其它:(a,(b),c)):\n");
	gets(p);
	StrAssign(t,p);
	CreateGList(l,t);
	printf("廣義表l的長度=%d\n",GListLength(l));
	printf("廣義表l的深度=%d l是否空？%d(1:是0:否)\n",GListDepth(l),GListEmpty(l));
	printf("遍歷廣義表l：\n");
	Traverse_GL(l,visit);
	printf("\n複製廣義表m=l\n");
	CopyGList(m,l);
	printf("廣義表m的長度=%d\n",GListLength(m));
	printf("廣義表m的深度=%d\n",GListDepth(m));
	printf("遍歷廣義表m：\n");
	Traverse_GL(m,visit);
	DestroyGList(m);
	m=GetHead(l);
	printf("\nm是l的表頭元素，遍歷m：\n");
	Traverse_GL(m,visit);
	DestroyGList(m);
	m=GetTail(l);
	printf("\nm是由l的表尾形成的廣義表，遍歷廣義表m：\n");
	Traverse_GL(m,visit);
	InsertFirst_GL(m,l);
	printf("\n插入廣義表l爲m的表頭，遍歷廣義表m：\n");
	Traverse_GL(m,visit);
	printf("\n刪除m的表頭，遍歷廣義表m：\n");
	DestroyGList(l);
	DeleteFirst_GL(m,l);
	Traverse_GL(m,visit);
	printf("\n");
	DestroyGList(m);
}

代碼的運行結果：

空廣義表l的深度=1 l是否空？1(1:是0:否)
請輸入廣義表l(書寫形式：空表:(),單原子:(a),其它:(a,(b),c)):
((),(e),(a,(b,c,d)))
廣義表l的長度=3
廣義表l的深度=3 l是否空？0(1:是0:否)
遍歷廣義表l：
e a b c d
複製廣義表m=l
廣義表m的長度=3
廣義表m的深度=3
遍歷廣義表m：
e a b c d
m是l的表頭元素，遍歷m：


m是由l的表尾形成的廣義表，遍歷廣義表m：
e a b c d
插入廣義表l爲m的表頭，遍歷廣義表m：
e a b c d e a b c d
刪除m的表頭，遍歷廣義表m：
e a b c d
Press any key to continue

// bo5-6.cpp 廣義表的擴展線性鏈表存儲(存儲結構由c5-6.h定義)的基本操作(13個)
#include"func5-1.cpp" // 算法5.8
void InitGList(GList1 &L)
{ // 創建空的廣義表L
	L=NULL;
}
void CreateGList(GList1 &L,SString S) // 算法5.7改
{ // 採用擴展線性鏈表存儲結構，由廣義表的書寫形式串S創建廣義表L。設emp="()"
	SString emp,sub,hsub;
	GList1 p;
	StrAssign(emp,"()"); // 設emp="()"
	if(!(L=(GList1)malloc(sizeof(GLNode1)))) // 建表結點不成功
		exit(OVERFLOW);
	if(!StrCompare(S,emp)) // 創建空表
	{
		L->tag=LIST;
		L->hp=L->tp=NULL;
	}
	else if(StrLength(S)==1) // 創建單原子廣義表
	{
		L->tag=ATOM;
		L->atom=S[1];
		L->tp=NULL;
	}
	else // 創建一般表
	{
		L->tag=LIST;
		L->tp=NULL;
		SubString(sub,S,2,StrLength(S)-2); // 脫外層括號(去掉第1個字符和最後1個字符)給串sub
		sever(sub,hsub); // 從sub中分離出表頭串hsub
		CreateGList(L->hp,hsub);
		p=L->hp;
		while(!StrEmpty(sub)) // 表尾不空，則重複建n個子表
		{
			sever(sub,hsub); // 從sub中分離出表頭串hsub
			CreateGList(p->tp,hsub);
			p=p->tp;
		};
	}
}
void DestroyGList(GList1 &L)
{ // 初始條件：廣義表L存在。操作結果：銷燬廣義表L
	GList1 ph,pt;
	if(L) // L不爲空表
	{ // 由ph和pt接替L的兩個指針
		if(L->tag) // 是子表
			ph=L->hp;
		else // 是原子
			ph=NULL;
		pt=L->tp;
		DestroyGList(ph); // 遞歸銷燬表ph
		DestroyGList(pt); // 遞歸銷燬表pt
		free(L); // 釋放L所指結點
		L=NULL; // 令L爲空
	}
}
void CopyGList(GList1 &T,GList1 L)
{ // 初始條件：廣義表L存在。操作結果：由廣義表L複製得到廣義表T
	T=NULL;
	if(L) // L不空
	{
		T=(GList1)malloc(sizeof(GLNode1));
		if(!T)
			exit(OVERFLOW);
		T->tag=L->tag; // 複製枚舉變量
		if(L->tag==ATOM) // 複製共用體部分
			T->atom=L->atom; // 複製單原子
		else
			CopyGList(T->hp,L->hp); // 複製子表
		if(L->tp==NULL) // 到表尾
			T->tp=L->tp;
		else
			CopyGList(T->tp,L->tp); // 複製子表
	}
}
int GListLength(GList1 L)
{ // 初始條件：廣義表L存在。操作結果：求廣義表L的長度，即元素個數
	int len=0;
	GList1 p=L->hp; // p指向第1個元素
	while(p)
	{
		len++;
		p=p->tp;
	};
	return len;
}
int GListDepth(GList1 L)
{ // 初始條件：廣義表L存在。操作結果：求廣義表L的深度
	int max,dep;
	GList1 pp;
	if(L==NULL||L->tag==LIST&&!L->hp)
		return 1; // 空表深度爲1
	else if(L->tag==ATOM)
		return 0; // 單原子表深度爲0，只會出現在遞歸調用中
	else // 求一般表的深度
		for(max=0,pp=L->hp;pp;pp=pp->tp)
		{
			dep=GListDepth(pp); // 求以pp爲頭指針的子表深度
			if(dep>max)
				max=dep;
		}
		return max+1; // 非空表的深度是各元素的深度的最大值加1
}
Status GListEmpty(GList1 L)
{ // 初始條件：廣義表L存在。操作結果：判定廣義表L是否爲空
	if(!L||L->tag==LIST&&!L->hp)
		return OK;
	else
		return ERROR;
}
GList1 GetHead(GList1 L)
{ // 生成廣義表L的表頭元素，返回指向這個元素的指針
	GList1 h,p;
	if(!L||L->tag==LIST&&!L->hp) // 空表無表頭
		return NULL;
	p=L->hp->tp; // p指向L的表尾
	L->hp->tp=NULL; // 截去L的表尾部分
	CopyGList(h,L->hp); // 將表頭元素複製給h
	L->hp->tp=p; // 恢復L的表尾(保持原L不變)
	return h;
}
GList1 GetTail(GList1 L)
{ // 將廣義表L的表尾生成爲廣義表，返回指向這個新廣義表的指針
	GList1 t,p;
	if(!L||L->tag==LIST&&!L->hp) // 空表無表尾
		return NULL;
	p=L->hp; // p指向表頭
	L->hp=p->tp; // 在L中刪去表頭
	CopyGList(t,L); // 將L的表尾拷給t
	L->hp=p; // 恢復L的表頭(保持原L不變)
	return t;
}
void InsertFirst_GL(GList1 &L,GList1 e)
{ // 初始條件：廣義表存在。操作結果：插入元素e(也可能是子表)作爲廣義表L的第1元素(表頭)
	GList1 p=L->hp;
	L->hp=e;
	e->tp=p;
}
void DeleteFirst_GL(GList1 &L,GList1 &e)
{ // 初始條件：廣義表L存在。操作結果：刪除廣義表L的第一元素，並用e返回其值
	if(L&&L->hp)
	{
		e=L->hp;
		L->hp=e->tp;
		e->tp=NULL;
	}
	else
		e=L;
}
void Traverse_GL(GList1 L,void(*v)(AtomType))
{ // 利用遞歸算法遍歷廣義表L
	GList1 hp;
	if(L) // L不空
	{
		if(L->tag==ATOM) // L爲單原子
		{
			v(L->atom);
			hp=NULL;
		}
		else // L爲子表
			hp=L->hp;
		Traverse_GL(hp,v);
		Traverse_GL(L->tp,v);
	}
}

// main5-6.cpp 檢驗bo5-6.cpp的主程序
#include"c1.h"
typedef char AtomType; // 定義原子類型爲字符型
#include"c5-6.h" // 定義廣義表的擴展線性鏈表存儲結構
#include"bo5-6.cpp" // 廣義表的擴展線性鏈表存儲結構基本操作
void visit(AtomType e)
{
	printf("%c ", e);
}
void main()
{
	char p[80];
	GList1 l,m;
	SString t;
	InitGList(l); // 建立空的廣義表l
	printf("空廣義表l的深度=%d l是否空？%d(1:是0:否)\n",GListDepth(l),GListEmpty(l));
	printf("請輸入廣義表l(書寫形式：空表:(),單原子:(a),其它:(a,(b),c)):\n");
	gets(p);
	StrAssign(t,p);
	CreateGList(l,t);
	printf("廣義表l的長度=%d\n",GListLength(l));
	printf("廣義表l的深度=%d l是否空？%d(1:是0:否)\n",GListDepth(l),GListEmpty(l));
	printf("遍歷廣義表l：\n");
	Traverse_GL(l,visit);
	printf("\n複製廣義表m=l\n");
	CopyGList(m,l);
	printf("廣義表m的長度=%d\n",GListLength(m));
	printf("廣義表m的深度=%d\n",GListDepth(m));
	printf("遍歷廣義表m：\n");
	Traverse_GL(m,visit);
	DestroyGList(m);
	m=GetHead(l);
	printf("\nm是l的表頭元素，遍歷m：\n");
	Traverse_GL(m,visit);
	DestroyGList(m);
	m=GetTail(l);
	printf("\nm是由l的表尾形成的廣義表，遍歷廣義表m：\n");
	Traverse_GL(m,visit);
	InsertFirst_GL(m,l);
	printf("\n插入廣義表l爲m的表頭，遍歷廣義表m：\n");
	Traverse_GL(m,visit);
	DeleteFirst_GL(m,l);
	printf("\n刪除m的表頭，遍歷廣義表m：\n");
	Traverse_GL(m,visit);
	printf("\n");
	DestroyGList(m);
}

代碼的運行結果：

空廣義表l的深度=1 l是否空？1(1:是0:否)
請輸入廣義表l(書寫形式：空表:(),單原子:(a),其它:(a,(b),c)):
(a,(b),c)
廣義表l的長度=3
廣義表l的深度=2 l是否空？0(1:是0:否)
遍歷廣義表l：
a b c
複製廣義表m=l
廣義表m的長度=3
廣義表m的深度=2
遍歷廣義表m：
a b c
m是l的表頭元素，遍歷m：
a
m是由l的表尾形成的廣義表，遍歷廣義表m：
b c
插入廣義表l爲m的表頭，遍歷廣義表m：
a b c b c
刪除m的表頭，遍歷廣義表m：
b c
Press any key to continue