c++实现广义表

原创 2016年06月01日 19:01:29


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

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

    

<1> A = ()

<2> B = (a,b)

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

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

<5> E = (((),()))

如下图所示:

wKioL1cYzm-j-4G4AABuzdcodP4424.png

广义表主要使用递归实现,表与表之间使用链式结构来存储。下面就来看看代码怎样实现的:

#pragma once

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

//节点类型
enum Type
{
	HEAD,//头节点
	VALUE,//数据项
	SUB,//子表的头节点
};

//广义表结构
struct GeneralizedNode
{
public:
	GeneralizedNode()//无参构造函数
		:_type(HEAD)
		, _next(NULL)
	{}

	GeneralizedNode(Type type, char ch = 0)
		:_type(type)
		,_next(NULL)
	{
		if (_type == VALUE)
		{
			_value = ch;//数据节点
		}
		if (_type == SUB)
		{
			_sublink = NULL;//子表节点
		}
	}

public:
	Type _type;//节点类型
	GeneralizedNode * _next;
	union
	{
		char _value;//数据
		GeneralizedNode * _sublink;//子表的头指针
	};
};

//广义表类
class Generalized
{
public:
	Generalized()//无参构造函数
		:_head(new GeneralizedNode(HEAD))
	{}
	Generalized(const char* str)//构造函数
		:_head(NULL)
	{
		_head = _CreateList(str);
	}

	Generalized(const Generalized & g)//拷贝构造
	{
		_head = _CopyList(g._head);
	}

	Generalized& operator=(Generalized g)//赋值运算符的重载
	{
		swap(_head, g._head);//现代写法
		return *this;
	}

	~Generalized()//析构函数
	{
		_Delete(_head);//递归析构
	}

public:
	void print()//打印
	{
		_Print(_head);
	}

	size_t size()//元素个数
	{
		size_t ret=_Size(_head);
		return ret;
	}

	size_t depth()//广义表的深度
	{
		size_t ret=_Depth(_head);
		return ret;
	}

public:
	GeneralizedNode * _CreateList(const char* &str)//创建广义表
	{
		assert(str&&*str == '(');
		//判断传入的广义表是否正确
		str++;//跳过'('

		GeneralizedNode* head = new GeneralizedNode();//创建头节点
		GeneralizedNode* cur = head;
		while (*str)
		{
			if (_IsVaild(*str))
			{
				cur->_next = new GeneralizedNode(VALUE, *str);//创建数据节点
				cur = cur->_next;//节点后移
				str++;//指针后移
			}
			else if (*str == '(')//子表
			{
				GeneralizedNode* SubNode = new GeneralizedNode(SUB);//创建字表的头节点
				SubNode->_sublink = _CreateList(str);//递归调用_CreateList函数
				cur->_next = SubNode;
				cur = cur->_next;
			}
			else if (*str == ')')//表的结束
			{
				str++;//跳过')'
				return head;//返回头节点
			}
			else//其他字符(' '或者',')
			{
				str++;
			}
		}
		assert(false);//强制判断程序是否出错
		return head;
	}

	bool _IsVaild(const char ch)//判断输入是否合理
	{
		if ((ch >= '0'&&ch <= '9')
			|| (ch >= 'a'&&ch <= 'z')
			|| (ch >= 'A'&&ch <= 'Z'))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	GeneralizedNode* _CopyList(GeneralizedNode* head)//复制
	{
		GeneralizedNode* cur = head;
		//创建新的头节点
		GeneralizedNode* newHead = new GeneralizedNode();
		GeneralizedNode* tmp = newHead;
		while (cur)
		{
			if (cur->_type == VALUE)//数据节点
			{
				tmp->_next = new GeneralizedNode(VALUE, cur->_value);
				tmp = tmp->_next;
			}
			else if (cur->_type == SUB)//子表节点
			{
				GeneralizedNode* SubNode = new GeneralizedNode(SUB);
				tmp->_next = SubNode;
				SubNode->_sublink = _CopyList(cur->_sublink);//递归调用
				
				tmp = tmp->_next;
			}
			cur = cur->_next;
		}
		return newHead;
	}

	void _Delete(GeneralizedNode * head)
	{
		GeneralizedNode* cur = head;
		while (cur)
		{
			GeneralizedNode* del = cur;
			if (cur->_type == SUB)//子表节点时递归析构
			{
				_Delete(cur->_sublink);
			}
			cur = cur->_next;
			delete del;
		}
	}

	void _Print(GeneralizedNode* head)//打印
	{
		GeneralizedNode* cur = head;
		if (cur == NULL)
		{
			return;
		}
		while (cur)
		{
			if (cur->_type == HEAD)
			{
				cout << "(";
			}
			else if (cur->_type == VALUE&&cur->_next)
			{
				cout << cur->_value<<",";
			}
			else if (cur->_type == VALUE&&cur->_next == NULL)
			{
				cout << cur->_value;
			}
			else if (cur->_type == SUB)
			{
				_Print(cur->_sublink);
				if (cur->_next)
				{
					cout << ",";
				}
			}
			cur = cur->_next;
		}
		if (cur == NULL)
		{
			cout << ")";
			return;
		}
	}

	size_t _Size(GeneralizedNode* head)//元素的个数
	{
		GeneralizedNode* cur = head;
		size_t count = 0;
		while (cur)
		{
			if (cur->_type == VALUE)
			{
				count++;
			}
			else if (cur->_type == SUB)
			{
				count += _Size(cur->_sublink);
			}
			cur = cur->_next;
		}
		return count;
	}

	size_t _Depth(GeneralizedNode* head)//广义表的深度
	{
		GeneralizedNode* cur = head;
		size_t depth = 1;
		while (cur)
		{
			if (cur->_type == VALUE)
			{
				depth++;
			}
			else if (cur->_type == SUB)
			{
				size_t newdepth = _Depth(cur->_sublink);
				if (newdepth++ > depth)//当后面子表的深度比现在的深时,更新深度
				{
					depth = newdepth++;
				}
			}
			cur = cur->_next;
		}
		return depth;
	}

private:
	GeneralizedNode * _head;
};

测试代码和结果如下:

void Test()
{
	Generalized g1("(a,b(c,d),(e,(f),h))");
	Generalized g2;
	g1.print();
	cout << endl;
	cout << "g1.size()="<< g1.size() << endl << endl;
	cout << "g1.depth()=" << g1.depth() << endl << endl;

	g2 = g1;
	g2.print();
	cout << endl;
	cout << "g2.size()=" << g1.size() << endl << endl;
	cout << "g2.depth()=" << g1.depth() << endl << endl;
}

wKiom1cYzzmzcTjgAAAKLKrr5qw498.png

本文出自 “不断进步的空间” 博客,请务必保留此出处http://10824050.blog.51cto.com/10814050/1766411

版权声明:本文为博主原创文章,未经博主允许不得转载。

广义表实现源码(C++、C)

  • 2017年03月12日 15:04
  • 3KB
  • 下载

广义表的实现(c++实现)

本文要点: 1.广义表的存储结构 2.广义表的简单实现,包括:构造、拷贝构造、赋值运算符重载、广义表的大小Size、深度Depth以及输出函数...

广义表(C++实现)

广义表在学稀疏矩阵之后就应该学的,只是那时觉得看起来晕晕就跳过了,现在回头学了一下,觉得还是不错的一种结构。下面是代码: 文件"glist.h" #include #include using n...

广义表的C++实现(包含构造函数,拷贝构造函数,析构函数,获取表头,表尾,获取直接后继等操作)

数据结构是数据在系统中的物理存储结构,自己编写数据结构可以对某种数据结构的物理和逻辑结构有更深的了解。 一、广义表作为一种数据结构有以下的特点: 1. 广义表是递归的; 2. 广义表的元素可以使广义表...
  • wpy_94
  • wpy_94
  • 2015年03月14日 12:53
  • 704

广义表的非递归深度优先遍历及相关运算的c++实现

对广义表的链表表示的深度优先遍历的实现要点是,从广义表的附加头节点开始向后顺序访问,对原子节点,访问结束后递进至下一节点,每遇到子表的附加头节点就进入该子表所在的下一层继续向下遍历,在下一层的子表中同...

C++实现广义表及其遍历

/* * GList.h * * Created on: Oct 19, 2015 * Author: chris */ #ifndef GLIST_H_ #define GL...

广义表C/C++实现详解

所谓的广义表就是单链表的扩展,就是节点可以是一个元素也可以是一个链表。官方的说法是,原子节点和子表节点。广义表用递归的方法来创建是最简单易懂的,也符合广义表的思想。C代码实现下载 C++代码实现下...

【代码】C++实现广义表及其测试用例

广义表是我第一次用递归接触链式的数据结构,其结构如下:    HEAD->VAL->VAL->LINK(->HEAD.....)->VAL->......    在这里,我们的头结点与link节点是不...
  • pawnsir
  • pawnsir
  • 2016年05月28日 18:36
  • 211

数据结构 C++ 二叉树 广义表

  • 2008年12月18日 20:37
  • 1.65MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:c++实现广义表
举报原因:
原因补充:

(最多只允许输入30个字)