j_0037.gif广义表

    广义表是一种非线性的数据结构,是线性表的一种推广。广义表中的元素既可以是一个元素,又可以是一个广义表,即广义表中可以嵌套很多子表


spacer.gifwKioL1cYU_vjh4pDAAA7NPpbnB0441.png

#include<iostream>
#include<assert.h>
using namespace std;

enum Type
{

	HEAD,//头结点
	VALUE,//值
	SUB,//子表
};
struct GeneralizedNode
{
	Type _type;//类型
	GeneralizedNode*_next;//指向下一个结点
	union
	{
	//值或者子表,公用一块空间
		char _value;
		GeneralizedNode*_subLink;
	};
	GeneralizedNode(Type type = HEAD, char value = 0)
		:_type(type)
		, _next(NULL)
	{
		if (_type == VALUE)
		{
			_value = value;
		}
		else if (_type == SUB)
		{
			_subLink = NULL;
		}
	}
};
class Generalized
{
public:
	Generalized()//无参构造函数
	:_head(new GeneralizedNode(HEAD))
	{}
	Generalized(const char*str)//有参构造函数
	{
		_head = _CreateList(str);
	}
	Generalized(const Generalized& g)//拷贝构造函数
	{
		_head = _copy(g._head);
	}

//赋值函数方法一:先释放结点再开辟空间拷贝,释放空间一定会成功单若开辟空间则易失败,造成拷贝失败
	/*Generalized&operator=(const Generalized&g)
	{
		if (this != &g)
		{
			_Destroy(_head);
			_head = _copy(g._head);
		}
		return *this;
	}*/
	//方法二:先
	/*Generalized&operator=(const Generalized&g)//赋值函数
	{
		if (this != g)
		{
			GeneralizedNode*tmp = _copy(g._head);
			_Destroy(_head);
			_head = tmp;
		}
		return *this;
	}*/
//方法三:直接交换,匿名变量出函数域析构
	Generalized&operator=( Generalized&g)
	{
		if (this != &g)
		{
			swap(_head, g._head);
		}
		return *this;
	}
	~Generalized()
	{
		_Destroy(_head);
	}
public:
	void Print()//打印表
	{
		_Print(_head);
		cout << endl;
	}
	size_t size()//表长度
	{
		return _size(_head);
	}
	size_t Depth()//深度
	{
		return _depth(_head);
	}
protected:
	bool _IsValue(char ch)//判断值是否合法范围内
	{
		if (ch >= '0'&&ch <= 9
			|| ch >= 'a'&&ch <= 'z'
			|| ch >= 'A'&&ch <= 'Z')
		{
			return true;
		}
		return false;
	}
	
	GeneralizedNode*_CreateList(const char* &str)//创建表
	{
		assert(str );
		assert(*str == '(');
		
		str++;//跳过第一个字符‘(’
		GeneralizedNode*head = new GeneralizedNode(HEAD);
		GeneralizedNode*cur = head;
		
		while (*str)
		{
			if (_IsValue(*str))//判断*str是否为字符串,若合法,插入
			{
				cur->_next = new GeneralizedNode(VALUE, *str);
				cur = cur->_next;
				str++;
				continue;
			}
			
			else if (*str == '(')
			{
				cur->_next = new GeneralizedNode(SUB);
				cur = cur->_next;
				cur->_subLink = _CreateList(str);//创建子表
				continue;
			}
			else if (*str == ')')
			{
				++str;
				return head;
			}
			else
			{
				str++;//为空格或者其他分隔符跳过
				continue;
			}
			assert(false);//强制判断是否错误(若字符串中括号匹配则程序不会走到这里)
		}
		return head;
	}
	void _Print(GeneralizedNode*head)
	{
		GeneralizedNode*cur = head;
		while (cur)
		{
			if (cur->_type == HEAD)
			{
				cout << '(' << " ";
				cur = cur->_next;
				continue;
			}
			if ((cur->_type == VALUE))
			{
				if (cur->_next == NULL)//如果是最后一个节点
				{
					cout << cur->_value << " "<<")";
					cur = cur->_next;
				}
				else
				{
					cout << cur->_value << " " << ",";
					cur = cur->_next;
				}
				continue;
			}

			if (cur->_type == SUB)
			{
				_Print(cur->_subLink);
				cur = cur->_next;
				if (cur != NULL)
				{
					cout << ",";
				}
				continue;
			}
			if (cur == NULL)
			{
				cout << ")";
				return;
			}
		}
	}
	GeneralizedNode* _copy(GeneralizedNode* head)
	{
		GeneralizedNode* cHead = new GeneralizedNode(HEAD);
		assert(head->_type == HEAD);//强制判断传入的结点是否为头类型
		GeneralizedNode* cur = head->_next;
		GeneralizedNode*tmp = cHead;
		while (cur)
		{
			if (cur->_type == VALUE)//拷贝字符
			{
				tmp->_next = new GeneralizedNode(VALUE,cur->_value);
				tmp = tmp->_next;
			}
			else if (cur->_type == SUB)//拷贝子表
			{
				tmp->_next = new GeneralizedNode(SUB);
				tmp = tmp->_next;
				tmp->_subLink = _copy(cur->_subLink);
			}
			cur = cur->_next;//循环
		}
		return cHead;
	}
	size_t _size(GeneralizedNode* head)
	{
		size_t count=0;
		GeneralizedNode* cur = head;
		while (cur)
		{
			if (cur->_type == VALUE)
			{
				count++;
				cur = cur->_next;
				continue;
			}
			if (cur->_type == SUB)
			{
				count += _size(cur->_subLink);
				cur = cur->_next;
				continue;
			}
			cur = cur->_next;
		}
		return count;
	}
	size_t _depth(GeneralizedNode*head)
	{
		int depth = 1;
		GeneralizedNode*cur = head;
		while (cur)
		{
			if (cur->_type == SUB)
			{
				int subdepth = _depth(cur->_subLink);
				if (subdepth + 1 > depth)
				{
					depth = subdepth + 1;
				}
			}
			cur = cur->_next;
		}
		return depth;
	}
	/*size_t _depth(GeneralizedNode*head)
	{
		GeneralizedNode*cur = head;
		size_t count = 0;
		size_t depth = 1;
		while (cur)
		{
			if (cur->_type == SUB)
			{
				depth += _subDepth(cur->_subLink);
			}
			cur = cur->_next;
			if (count < depth)
			{
				count=depth;
				depth = 1;
			}
		}
		return count;
	}
	size_t _subDepth(GeneralizedNode*subHead)//子表
	{
		GeneralizedNode* cur = subHead;
		size_t dep = 1;
		while (cur)
		{
			if (cur->_type == SUB)
			{
				dep = dep + _subDepth(cur->_subLink);
			}
			cur = cur->_next;
		}
		return dep;
	}*/
	

	void _Destroy(GeneralizedNode* head)//析构
	{
		GeneralizedNode*cur = head;
		while (cur)
		{
			if (cur->_type == SUB)
			{
				_Destroy(cur->_subLink);//递归析构子表
			}
			GeneralizedNode* del = cur;
			cur = cur->_next;
			delete del;
		}
	}
private:
	GeneralizedNode*_head;
};
int main()
{
	char ch[] = "(a,b,(c,d,(e),f),g)";
	Generalized g1(ch);
	g1.Print();
	cout << g1.size() << endl;
	cout << g1.Depth() << endl;
	Generalized g2;
		g2= g1;
		g2.Print();
		Generalized g3(g2);
		g3.Print();
}