广义表的创建及成员函数的实现

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

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

例如：

(1)A = ()

(2)B = (a,b)

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

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

广义表的结构：

因此，广义表中包含三种节点，头节点，子表节点，值节点

我们可以定义这样一个结构体：

enum Type
{
	HEAD,//头节点
	VALUE,//值
	SUB//子表节点
};

struct GeneralizedNode//广义表节点
{
	GeneralizedNode(const Type& type = HEAD,const char& value='0')
	:_next(NULL)
	,_SubLink(NULL)
	, _type(type)
	{
		_value = value;
	}
	Type _type;//节点类型
	GeneralizedNode* _next;//指向同层下一个节点的地址
	union
	{
		char _value;//值
		GeneralizedNode* _SubLink;//指向子表指针
	};
};

用联合使得节点中指向子表的指针和值共用一块空间，由于子表节点中只有指向的子表指针，而值节点只有值，两者可共用一块空间。

广义表中有子表，因此它的实现可看做子问题，可用递归实现。

由于成员函数不可以递归调用，实现广义表的成员函数需要递归时，应该定义另外一个函数用来实现其功能。

广义表的实现：

#pragma once

#include
#include

using namespace std;


enum Type
{
	HEAD,//头节点
	VALUE,//值
	SUB//子表节点
};

struct GeneralizedNode//广义表节点
{
	GeneralizedNode(const Type& type = HEAD,const char& value='0')
	:_next(NULL)
	,_SubLink(NULL)
	, _type(type)
	{
		_value = value;
	}
	Type _type;//节点类型
	GeneralizedNode* _next;//指向同层下一个节点的地址
	union
	{
		char _value;//值
		GeneralizedNode* _SubLink;//指向子表指针
	};
};

class Generalized
{
public:
	Generalized()
	:_head(NULL)
	{}
	Generalized(const char *str)
		:_head(NULL)
	{
		_head = _CreatList(str);
	}
	Generalized(const Generalized& g)
		:_head(NULL)
	{
		_head=CopyGeneralized(g._head);
	}
	/*Generalized& operator=(Generalized g)
	{
		swap(_head, g._head);
		return *this;
	}*/
	Generalized& operator=(const Generalized& g)
	{
		if (this != &g)
		{
			GeneralizedNode *tmp = CopyGeneralized(g._head);
			_DelGeneralized(_head);
			_head =tmp;
		}
		return *this;
	}

	~Generalized()
	{
		_DelGeneralized(_head);
		_head = NULL;
	}
	void Print()
	{
		_Print(_head);
	}
	size_t Size()
	{
		return _Size(_head);
	}
	size_t Depth()
	{
		return _Depth(_head);
	}
protected:
	size_t _Depth(GeneralizedNode *head)
		//深度是计算广义表中最深的表的深度
	{
		int depth = 1;//刚开始默认最深的表深度为1
		GeneralizedNode* cur = head;
		while (cur)
		{
			if (cur->_type == SUB)//若遇到子表
			{
				int subdepth = _Depth(cur->_SubLink);//递归计算子表的深度
				if (subdepth+1 > depth)//若子表深度加1（广义表的目前最深度）大于原来广义表的深度
				{
					depth = subdepth+1;//重置广义表最深度置
				}
			}
			cur = cur->_next;
		}
		return depth;
	}
	size_t _Size(GeneralizedNode *head)//广义表中元素的个数
	{
		int count = 0;
		
		GeneralizedNode* cur = head;
		while (cur)
		{
			if (cur->_type == VALUE)
			{
				count++;
			}
			else if (cur->_type == SUB)
			{
				count += _Size(cur->_SubLink);
			}
			cur = cur->_next;
		}
		return count;
	}
	GeneralizedNode* CopyGeneralized(GeneralizedNode* head)
	{
		GeneralizedNode* chead = new GeneralizedNode(HEAD);
		 GeneralizedNode* cur = head->_next;
		 GeneralizedNode* _cur = chead;
		while (cur)
		{
			if (cur->_type == VALUE)
			{
				_cur->_next = new GeneralizedNode(VALUE, cur->_value);
				_cur = _cur->_next;
			}
			else if (cur->_type == SUB)
			{
				
				_cur->_next = new GeneralizedNode(SUB);
				_cur = _cur->_next;
				_cur->_SubLink=CopyGeneralized(cur->_SubLink);
			}
			cur = cur->_next;
		}
		return chead;
	}

	void _DelGeneralized(GeneralizedNode* head)
	{
		if (head == NULL)
			return;
		GeneralizedNode* cur = head;
		GeneralizedNode* del = NULL;
		while (cur)
		{
			del = cur;
			if (cur->_type == SUB)//遇到子表节点时看做子问题
			{
				_DelGeneralized(cur->_SubLink);
			}
			cur = cur->_next;
			delete del;
		}
	}
	bool IsValue(char ch)
	{
		if ((ch >= '0'&& ch <= '9') || (ch >= 'a'&& ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
			return true;
		else
			return false;
	}
	void _Print(GeneralizedNode* &head)
	{
		assert(head);
		GeneralizedNode* cur = head;
		bool IsInTable = true;
		while (cur)
		{
			if (cur->_type == HEAD)
			{
				cout << "(";
				cur = cur->_next;
				if (cur == NULL)
					cout << ")";
			}
			else if (cur->_type == VALUE)
			{
				cout << cur->_value;
				if (cur->_next != NULL)
					cout << ",";
				else
				{
					cout << ")";
					return;
				}
				cur = cur->_next;
			}
			else if(cur->_type == SUB)
			{
				_Print(cur->_SubLink);
				if (cur->_next != NULL)
					cout << ",";
				else
					cout << ")";
				cur = cur->_next;
			}
		}
	}
	GeneralizedNode* _CreatList(const char* &str)
	{

		assert(str && *str == '(');
		++str;
		GeneralizedNode* head = new GeneralizedNode(HEAD);
		GeneralizedNode* cur = head;
		while (*str)
		{
			if (IsValue(*str))//若节点值是合法值
			{
				cur->_next = new GeneralizedNode(VALUE,*str);//则创建一个值节点
				cur = cur->_next;
				str++;
			}
			else if (*str == '(')//遇到'('表示它是一个子表节点
			{
				cur->_next = new GeneralizedNode(SUB);//创建一个子表节点
				cur = cur->_next;
				cur->_SubLink = _CreatList(str);//递归解决子表的创建
			}
			else if (*str == ')')//遇到')'说明一个广义表或者子表结束
			{
				++str;
				return head;//返回子表的头节点，或广义表的头节点
			}
			else
				++str;
		}
		assert(false);
		return head;
	}
private:
	GeneralizedNode* _head;
};

测试程序：

#include "GeneralizedList.h"

void TestGeneralized()
{
	char str[] = "(a,b,c,(d,e),(f,(g,(()),h),i))";
	Generalized g1(str);
	g1.Print();
	
	cout << endl;
	cout << g1.Depth() << endl;
	cout << g1.Size() << endl;
	Generalized g2(g1);
	g2.Print();
	cout << endl;
	Generalized g3;
	g3 = g1;
	g3.Print();

}

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

运行结果：