数据结构-广义表

广义表(Lists，又称列表)是一种非线性的数据结构，是线性表的一种推广。

它被广泛的应用于人工智能等领域的表处理语言LISP语言中。在LISP语言中，广义表是一种最基本的数据结构，就连LISP 语言的程序也表示为一系列的广义表。

因为表中有表，所以可以用递归进行解决广义表的问题。

#pragma once 
#include<assert.h>

enum Type//用枚举形式来定义广义表中三种节点类型
{
	HEAD, //头类型
	VALUE,//值类型
	SUB,//子表类型
};

struct GeneralizedNode
{
	Type _type;//类型
	GeneralizedNode* _next;
	union
	{
		int _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(NULL)
	{}

	~Generalized()
	{
		_Destroy(_head);
	}

	Generalized(const char* str)
	{
		_head = _CreateList(str);
	}
	Generalized(const Generalized& g)
	{
		_head = _Copy(g._head);

	}

	Generalized& operator=(const Generalized& g)
	{
		if (this != &g)
		{
			GeneralizedNode* tmp = _Copy(g._head);
			_Destroy(_head);
			_head = tmp;
		}
		return *this;
	}

	void Print()
	{
		_Print(_head);
		cout << endl;
	}

	size_t Size()
	{
		return _Size(_head);
	}
	size_t Depth()
	{
		return _Depth(_head);
	}

protected:

	void _Destroy(GeneralizedNode* head)
	{
		GeneralizedNode* cur = head;
		while (cur)
		{
			GeneralizedNode* del = cur;
			cur = cur->_next;
			if (del->_type == SUB)
			{
				_Destroy(del->_sublink);
			}
			delete del;
		}
	}

	GeneralizedNode*  _Copy(GeneralizedNode* head)
	{
		GeneralizedNode* newHead = new GeneralizedNode(HEAD);
		GeneralizedNode* cur = head->_next;

		GeneralizedNode* newcur = newHead;
		while (cur)
		{
			if (cur->_type == VALUE)
			{
				newcur->_next = new GeneralizedNode(VALUE, cur->_value);
				newcur = newcur->_next;
			}
			else if (cur->_type == SUB)
			{
				//newcur->_next = new GeneralizedNode(SUB);

				GeneralizedNode* newSublink= new GeneralizedNode(SUB);
				newcur->_next = newSublink;
				newcur = newcur->_next;
				newcur->_sublink = _Copy(cur->_sublink);
			}
			
			cur = cur->_next;
		}
		return newHead;
	}

	GeneralizedNode* _CreateList(const char*&str)
	{
		assert(*str == '(');
		++str;
		GeneralizedNode* head = new GeneralizedNode(HEAD);
		GeneralizedNode* cur = head;
		while (*str)
		{
			if (isStr(*str))
			{
				cur->_next = new GeneralizedNode(VALUE, *str);
				cur = cur->_next;
				++str;  //attention
			}
			else if (*str == '(')
			{
				GeneralizedNode* SubNode = new GeneralizedNode(SUB);
				cur->_next = SubNode;
				cur = cur->_next;
				SubNode->_sublink = _CreateList(str);
			}
			else if (*str == ')')
			{
				str++;
				return head;
			}
			else
			{
				str++;
			}
		}
		cout << "广义表出错！" << endl;
		assert(false);
		return head;
	}


	size_t _Depth(GeneralizedNode* head)
	{
		size_t depth = 1;
		GeneralizedNode* cur = head;
		while (cur)
		{
			if (cur->_type == SUB)
			{
				size_t subdepth= _Depth(cur->_sublink)+1;
				if (subdepth > depth)
				{
					depth = subdepth;
				}
			}
			cur = cur->_next;
		}
		return depth;
	}


	size_t _Size(GeneralizedNode* head)
	{
		size_t size = 0;
		if (head == NULL)
			return 0;
		GeneralizedNode* cur = head;
		while (cur)
		{
			if (cur->_type == VALUE)
			{
				++size;
			}
			else if (cur->_type == SUB)
			{
				//+=
				size+=_Size(cur->_sublink);
			}
			cur = cur->_next;
		}
		return size;
	}
	void _Print(GeneralizedNode* head)
	{
		GeneralizedNode* cur = head;
		while (cur)
		{
			if (cur->_type == HEAD)
			{
				cout << "(";
			}
			else if (cur->_type == VALUE)
			{
				cout << (char)(cur->_value);
				if (cur->_next)
				{
					cout << ",";
				}
			}
			else if (cur->_type == SUB)
			{
				_Print(cur->_sublink);
				if (cur->_next)
				{
					cout << ",";
				}
			}
			cur = cur->_next;
		}
		cout << ")";
	}

	bool isStr( char str)
	{
		if ((str >= 'a'&&str <= 'z') ||
			(str >= 0&&str <= 9)||
			(str >= 'A'&&str <= 'Z'))
		{
			return true;
		}
		else
		{
			return false;
		}
	}


protected:
	GeneralizedNode* _head;

};



void Test()
{
	Generalized g1("()");
	Generalized g2("(a,b,(c,d))");
	Generalized g3("(a,b,(c,d),(e,(f),h)) ");
	Generalized g4(g2);
	g4.Print();


	Generalized g5;
	g5 = g3;
	g5.Print();


	//g1.Print();
	//cout << endl;
	//g2.Print();
	//cout << endl;

	//g3.Print();
	//cout << endl;

	//cout << "g3:size:" << g3.Size() << endl;
	//cout << "g1:depth:" << g1.Depth() << endl;
	//cout << "g2:depth:" << g2.Depth() << endl;
	//cout << "g3:depth:" << g3.Depth() << endl;
}