c++实现广义表

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

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

<1> A = ()

<2> B = (a,b)

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

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

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

如下图所示:

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

#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;
}

时间: 2024-10-12 20:15:02

c++实现广义表的相关文章

c++数据结构之广义表

最近学习了广义表,我们知道广义表也是一种线性表,而顾名思义广义表就是不止一个表,下面来举个栗子: A=( ) B=(1 , 2,3) C=(1 ,2 ,3, ( a , b ,c) ) D=(1, 2, 3, (a,( b,c),d),4) 以上A,B,C,D都是广义表,只不过深度不一样,也就是括号的对数不一样,A是个特殊的广义表,即空表.B里面有三个元素,C里面有6个元素,包括一个子表(a,b,c),C也同理,只不过多了一层子表.由此可总结为一句话:表里有表 这样看可能不太直观,下面以广义表C

数据结构实践项目——数组和广义表

本文针对 [数据结构基础系列网络课程(5):数组和广义表] 1. 数组的基本概念与存储结构 2. 特殊矩阵的压缩存储 3. 稀疏矩阵的三元组表示 4. 稀疏矩阵的十字链表表示 5. 广义表 6. 广义表的存储结构及基本运算的实现 [项目1 - 猴子选大王(数组版)] 一群猴子,编号是1,2,3 -m,这群猴子(m个)按照1-m的顺序围坐一圈.从第1只开始数,每数到第n个,该猴子就要离开此圈,这样依次下来,最后一只出圈的猴子为大王.输入m和n,输出猴子离开圈子的顺序,从中也可以看出最后为大王是几号

数据结构与算法系列研究四——数组和广义表

稀疏矩阵的十字链表实现和转置 一.数组和广义表的定义 数组的定义1:一个 N 维数组是受 N 组线性关系约束的线性表.           二维数组的逻辑结构可形式地描述为:           2_ARRAY(D,R)              其中 D={aij} | i=0,1,...,b1-1; j=0,1,...,b2-1;aij∈D0}              R={Row,Col}              Row={<aij,ai,j+1>|0<=i<=b1-1;

广义表的实现

/*--------------------------------------------------------------------- 广义表的存储结构 ---------------------------------------------------------------------*/ #include<stdio.h> #include<stdlib.h> typedef char ElemType;//元素类型是字符型 //广义表的存储结构 struct GN

广义表的实现(法二)

#include<iostream> #include<string> using namespace std; enum elemTag {ATOM,LIST}; class GList; class GLnode { private: elemTag Tag; //标志是原子还是子表 0:原子 1:子表 union { char data; //原子结点值域 struct //表结点指针域 { GLnode *hp; GLnode *tp; }ptr; }; friend cl

广义表

其中包括广义表的创建.输出.拷贝构造.赋值运算符重载.析构.有效数据个数以及广义表深度 #pragma once #include<iostream> #include<assert.h> #include<ctype.h> using namespace std; enum Type {  HEAD, VALUE, SUB };//头结点.值.子表 struct GeneralizedNode {  Type _type;  //广义表结点类型  Generalize

数据结构之广义表

#include<stdio.h> //广义表的头尾链表存储结构 typedef int AtomType; typedef enum NodeType{ATOM,LIST}ElemTag;//ATOM表示原子结点,LIST表示表节点 typedef struct GLNode{ ElemTag tag; union{ AtomType atom; struct List{ struct GLNode* hp,*tp; } htp; }atom_htp; }GLNode,*GList; //求

数据结构——广义表

定义 Python中的list就是一种广义表,使用起来非常方便.广义表的特点就是能够存储不同类型的元素,也支持嵌套使用,即表中还有表.关于广义表的定义还有几本操作归纳如下: ADT Linear List: 元素组成: 能存储不同元素类型的表结构叫做广义表,支持嵌套操作. 基本操作: InitGList() 创建一个空表 DestoryGList() 销毁一个表 GListLength()  获取表的长度 GListDepth()  获取表的深度 PrintList() 遍历一次表 Insert

33. 蛤蟆的数据结构笔记之三十三广义表实现二

33. 蛤蟆的数据结构笔记之三十三广义表实现二 本篇名言:" 希望是附丽于存在的,有存在,便有希望,有希望,便是光明.--鲁迅" 我们继续来看下广义表的其他代码实现.代码均来自网络,解释来自蛤蟆,均亲测可行. 欢迎转载,转载请标明出处: 1.  广义表实现二 1.1         main 创建两个链表的指针head和L. 输入一个字符串,调用GLCreate函数创建广义表.显示,获取头表,尾表,输出长度,深度,原子个数,复制列表,Merge列表,遍历,比较广义表操作. 如下图1:

数据结构之---C语言实现广义表头尾链表存储表示

//广义表的头尾链表存储表示 //杨鑫 #include <stdio.h> #include <malloc.h> #include <stdlib.h> #include <string.h> #define MAXSTRLEN 40 ) typedef char SString[MAXSTRLEN+1]; typedef char AtomType; // 定义原子类型为字符型 typedef enum{ ATOM, LIST // ATOM==0:原