广义表的建立与一般操作C\C++

最新推荐文章于 2022-11-28 22:49:57 发布
最新推荐文章于 2022-11-28 22:49:57 发布
阅读量7.4k 收藏 33
点赞数 4
分类专栏： 数据结构 文章标签： c语言 数据结构 广义表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g15827636417/article/details/52876725
版权

广义表的建立与一般操作C\C++

一、广义表的概念
        广义表是线性表的推广，但线性表的元素仅限于原子项，原子作为结构上不可分割的成分，它可以是一个数或一个结构，若放松对表元素的这种限制，允许它们具有自身独立类型结构，就产生了广义表的概念。
       广义表是n(n>=0)个数据元素a1,a2,......ai,......,an的有序序列，一般记作：
                                                                                                                                    ls = (a1,a2 ,........,ai, ...an)
      其中：ls是广义表的名称，n是它的长度。
二、广义表的数据结构
A = ()
B = (e)
C = (a,(b,(c,d)))
D = ((),B,C)
E = (a,E)
F = (())

图中为广义表的头尾表示法
头尾表示法的存储结构： 
typedef enum {ATOM , LIST} Elemtag ;
typedef struct node
{
    Elemtag tag ; //用以标记是单个元素或广义表
    union
    {
        datatype data ;
        struct
        {
            struct node *hp , *tp ; //指向广义表头节点和尾节点的指针
        } ptr ;
    };
} GLNode , *GList ;
孩子兄弟表示法的存储结构： 
typedef enum {ATOM , LIST} ELemtag ;
typedef struct GLENode{
  Elemtag tag ;
 union{
  datatype data ;
  struct GLENode *hp ;
  }
struct GLENode *tp ;
} *EGList ;
三、广义表的操作
1、广义表的取头、取尾操作 
/*
 *广义表的取头操作
 */
GList GetHead(GList ls)
{
    GList list = NULL ;
    if(ls->tag == 1)
    {
        list = ls->ptr.hp ;
    }
    return list ;
}
/*
 *广义表的取尾操作
 */
GList GetTail(GList ls)
{
    GList list = NULL ;
    if(ls->tag == 1)
    {
        list = ls->ptr.tp ;
    }
    return list ;
}
2、建立广义表的存储结构 
/*
 *将字符串分为表头和表尾字符串
 */
void server(char *hsub , char *s)
{
   int i , k ;
   for(i = 0 , k = 0 ; i < strlen(s) ; i++)
   {
       if(s[i] == '(')
       {
           k++;
       }
       if(s[i] == ')')
       {
           k--;
       }
       if(s[i] == ',' && k == 0)
       {
           break ;
       }
   }
   if(i < strlen(s))
   {
       substr(s , hsub , 1 , i) ;
       substr(s , s , i + 2 , strlen(s) - i - 1) ;
   }
   else
   {
       substr(s , hsub , 1 ,strlen(s)) ;
       s[0] = '\0' ;
   }
}
/*
 *建立广义表的存储结构
 */
int CreateGList(GList *ls , char *s)
{
    GLNode *p , *q ;
    char hsub[MAXSIZE] ;
    //字符串为空时，广义表为空
    if(s == NULL)
    {
        *ls = NULL ;
    }
    else
    {
        if(!(*ls = (GList)malloc(sizeof(GLNode))))
        {
            return 0 ;
        }
        //字符长度为1时，广义表为单个元素
        if(strlen(s) == 1)
        {
            (*ls)->tag = 0 ;
            (*ls)->data = *s ;
        }
        else
        {
            substr(s , s , 2 , strlen(s) - 2) ; //去掉最外层括号;
            p = (*ls) ;
            p->tag = 1 ;
            do
            {
                server(hsub , s) ; //获取头节点
                CreateGList(&(p->ptr.hp) , hsub) ;
                q = p ;
                if(*s != '\0')
                {
                    p = (GList)malloc(sizeof(GLNode)) ;
                    p->tag = 1 ;
                    q->ptr.tp = p ;
                }
                else
                {
                    p->ptr.tp = NULL ;
                }
            }while(*s != '\0') ;
        }
    }
    return 1 ;
}
3、以表头、表尾建立广义表 
/*
 *以表头和表尾建立广义表
 */
int Merge(GList l1 , GList l2 , GList *ls)
{
    if(!((*ls) = (GList)malloc(sizeof(GLNode))))
    {
        return 0 ;
    }
    (*ls)->tag = 1 ;
    (*ls)->ptr.hp = l1 ;
    (*ls)->ptr.tp = l2 ;
    return 1 ;
}
4、求广义表的长度 
/*
 *取得广义表的长度
 */
int Depth(GList ls)
{
    GList p ;
    int max , depth ;
    if(ls == NULL)
    {
        return 1 ; //空表长度为1
    }
    if(ls->tag == 0)
    {
        return 0 ; //单元素长度为0
    }
    for(max = 0 , p = ls->ptr.tp; p ; p = p->ptr.tp)
    {
        depth = Depth(p) ;
        if(depth > max)
        {
            max = depth ;
        }
    }
    return max + 1 ;
}
5、复制广义表 
/*
 *进行广义表的复制
 */
int CopyGList(GList ls , GList *ls1)
{
    if(ls == NULL)
    {
        (*ls1) = NULL ;
    }
    else
    {
        if(!((*ls1)=(GList)malloc(sizeof(GLNode))))
        {
            return 0 ;
        }
        if(ls->tag == 0)
        {
            (*ls1)->tag = 0 ;
            (*ls1)->data = ls->data ;
        }
        else
        {
            (*ls1)->tag = 1 ;
            CopyGList(ls->ptr.hp , &((*ls1)->ptr.hp)) ;
            CopyGList(ls->ptr.tp , &((*ls1)->ptr.tp)) ;
        }
    }
}
四、测试的全部代码 
/*
 *操作均是建立在关于建立在头尾指针的广义表上
 */
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#define MAXSIZE 100
/*
 *定义广义表节点的存储结构
 */
typedef char datatype ;
typedef enum {ATOM , LIST} Elemtag ;
typedef struct node
{
    Elemtag tag ; //用以标记是单个元素或广义表
    union
    {
        datatype data ;
        struct
        {
            struct node *hp , *tp ; //指向广义表头节点和尾节点的指针
        } ptr ;
    };
} GLNode , *GList ;
/*
 *进行字符串的裁剪，s为被裁剪的对象
 */
void substr(char *s , char *sub , int startIndex , int len)
{
   int i ;
   for(i = 1 ; i < startIndex ; s++ , i++) ;
   for(i = 0 ; i < len ; i++)
   {
       sub[i] = s[i] ;
   }
   sub[len] = '\0' ;
}
/*
 *将字符串分为表头和表尾字符串
 */
void server(char *hsub , char *s)
{
   int i , k ;
   for(i = 0 , k = 0 ; i < strlen(s) ; i++)
   {
       if(s[i] == '(')
       {
           k++;
       }
       if(s[i] == ')')
       {
           k--;
       }
       if(s[i] == ',' && k == 0)
       {
           break ;
       }
   }
   if(i < strlen(s))
   {
       substr(s , hsub , 1 , i) ;
       substr(s , s , i + 2 , strlen(s) - i - 1) ;
   }
   else
   {
       substr(s , hsub , 1 ,strlen(s)) ;
       s[0] = '\0' ;
   }
}
/*
 *建立广义表的存储结构
 */
int CreateGList(GList *ls , char *s)
{
    GLNode *p , *q ;
    char hsub[MAXSIZE] ;
    //字符串为空时，广义表为空
    if(s == NULL)
    {
        *ls = NULL ;
    }
    else
    {
        if(!(*ls = (GList)malloc(sizeof(GLNode))))
        {
            return 0 ;
        }
        //字符长度为1时，广义表为单个元素
        if(strlen(s) == 1)
        {
            (*ls)->tag = 0 ;
            (*ls)->data = *s ;
        }
        else
        {
            substr(s , s , 2 , strlen(s) - 2) ; //去掉最外层括号;
            p = (*ls) ;
            p->tag = 1 ;
            do
            {
                server(hsub , s) ; //获取头节点
                CreateGList(&(p->ptr.hp) , hsub) ;
                q = p ;
                if(*s != '\0')
                {
                    p = (GList)malloc(sizeof(GLNode)) ;
                    p->tag = 1 ;
                    q->ptr.tp = p ;
                }
                else
                {
                    p->ptr.tp = NULL ;
                }
            }while(*s != '\0') ;
        }
    }
    return 1 ;
}
/*
 *打印广义表
 */
void printGList(GList ls)
{
    if(ls != NULL)
    {
        if(ls->tag == 0)
        {
            printf("%c " , ls->data) ;
        }
        else
        {
            printGList(ls->ptr.hp) ;
            printGList(ls->ptr.tp) ;
        }
    }
}
/*
 *以表头和表尾建立广义表
 */
int Merge(GList l1 , GList l2 , GList *ls)
{
    if(!((*ls) = (GList)malloc(sizeof(GLNode))))
    {
        return 0 ;
    }
    (*ls)->tag = 1 ;
    (*ls)->ptr.hp = l1 ;
    (*ls)->ptr.tp = l2 ;
    return 1 ;
}
/*
 *取得广义表的长度
 */
int Depth(GList ls)
{
    GList p ;
    int max , depth ;
    if(ls == NULL)
    {
        return 1 ; //空表长度为1
    }
    if(ls->tag == 0)
    {
        return 0 ; //单元素长度为0
    }
    for(max = 0 , p = ls->ptr.tp; p ; p = p->ptr.tp)
    {
        depth = Depth(p) ;
        if(depth > max)
        {
            max = depth ;
        }
    }
    return max + 1 ;
}
/*
 *进行广义表的复制
 */
int CopyGList(GList ls , GList *ls1)
{
    if(ls == NULL)
    {
        (*ls1) = NULL ;
    }
    else
    {
        if(!((*ls1)=(GList)malloc(sizeof(GLNode))))
        {
            return 0 ;
        }
        if(ls->tag == 0)
        {
            (*ls1)->tag = 0 ;
            (*ls1)->data = ls->data ;
        }
        else
        {
            (*ls1)->tag = 1 ;
            CopyGList(ls->ptr.hp , &((*ls1)->ptr.hp)) ;
            CopyGList(ls->ptr.tp , &((*ls1)->ptr.tp)) ;
        }
    }
}
/*
 *广义表的取头操作
 */
GList GetHead(GList ls)
{
    GList list = NULL ;
    if(ls->tag == 1)
    {
        list = ls->ptr.hp ;
    }
    return list ;
}
/*
 *广义表的取尾操作
 */
GList GetTail(GList ls)
{
    GList list = NULL ;
    if(ls->tag == 1)
    {
        list = ls->ptr.tp ;
    }
    return list ;
}
//进行广义表的测试
void main()
{
  GList ls1 , ls2 , ls3 , ls4 ;
  char s[MAXSIZE] , s1[MAXSIZE];
  scanf("%s" , s) ;
  CreateGList(&ls1 , s) ;
  scanf("%s" , s1) ;
  CreateGList(&ls2 , s1) ;
  printGList(ls1) ;
  printf("\n") ;
  printGList(ls2) ;
  printf("\n") ;
  printf("the depth of ls1 is %d \n" , Depth(ls1)) ;
  printf("the depth of ls2 is %d \n" , Depth(ls2)) ;
  Merge(ls1 , ls2 , &ls3) ;
  printGList(ls3) ;
  printf("\n") ;
  printf("the depth of ls3 is %d \n" , Depth(ls3)) ;
  CopyGList(ls3 , &ls4) ;
  printGList(ls4) ;
  printf("\n") ;
  printf("the depth of ls4 is %d \n" , Depth(ls4)) ;
}








luo___ye
关注
  • 4
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c/c++：数据结构——广义表的应用
走向CTO的路上...
11-29 1043
每个节点包含一个数据元素、一个指向第一个子节点的指针（child）、一个指向下一个兄弟节点的指针（sibling）。广义表是一种扩展了线性表的数据结构，可以存储多层次、多叉的数据。下面是一个示例的C++代码，实现了广义表的建立、查找、输出、取表头和取表尾以及求深度等功能。广义表的概念在计算机科学中非常常见，因此有很多产品和库在使用广义表或类似的数据结构。广义表的应用场景非常广泛，特别适用于需要处理层次结构数据的场景。要求实现的广义表的建立、查找、输出、取表头和取表尾以及求深度等。(6)求广义表的深度。
C++建立顺序存储完全二叉树并以广义表形式输出
Goallegoal的博客
12-09 927
建立顺序存储完全二叉树并以广义表形式输出 题目要求： 假设用顺序表来表示一棵完全二叉树。从根到叶结点按层次从 1 开始编号，同一层次从左到右编号，数据存储在对应的数组元素中。试编写算法由此顺序存储结构建立该二叉树的二叉链表。 输入格式： 输入只有一行，为顺序输入的从根节点开始的各个节点元素，它们之间用空格隔开，整个输入以 $ 结束。 输出格式： 输出有一行，为二叉树结构的广义表达式。 样例输入： A B C D $ 样例输出： A(B(D),C) 解题思路： 由完全二叉树的特点可得，若
广义表的基本操作
11-16
广义表的数据结构和基本操作，含广义表的表达式合法性判断。
广义表基本操作
qq_45762564的博客
11-24 2049
#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
广义表的基本操作实现
热门推荐
在路上
04-21 1万+
广义表的四个特征：（1）广义线性表；（2）元素复合性；（3）元素递归性；（4）元素共享性     广义表的上述四个特征对于他的使用价值和应用效果起到了很大的作用。广义表的结构相当灵活，它可以兼容线性表、数组、树和有向图等各种常用的数据结构。当二维数组的每行或每列作为子表处理时，二维数组就是一个广义表；如果限制广义表中元素的共享和递归，广义表和树对应；如果限制广义表的递归并允许数据共享，则广义表和
广义表的创建及基本操作
cjj
09-08 2384
目录存储结构（头尾链）结构图代码 存储结构（头尾链） 结构图 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200908205134403.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0ODQzMTQ0,size_16,color_FFFFFF,t_70#pic_center) 代码 .
广义表 —— C++实现
bit16Girl的博客
11-28 1298
广 义 表 ——C++ 实现 苦b南信带带二计软院本科生开始做数据结构作业辣！！ 题目：编程实现 广 义 表: A=(), B=(a,(b,c,d)) C=(e),D=(A,B,C,f) (1)复制广义表B (2)求广义表D深度。 欧K，开始应付作业8 什么？应付作业？那怎么能对得起大学辛苦的栽培！？还有严蔚敏奶奶辛苦写的课本！？ 于是决定搞个 带 工 程 那么首先考虑的是从用户（...
广义表创建二叉树及二叉树输出广义表
12-24
在计算机科学中，二叉树是一种特殊的图结构，其中每个节点最多有两个子节点，通常分为左子节点和右子节点。而广义表（Generalized List）是...理解这些概念和方法对于理解和操作二叉树及其与广义表之间的转换至关重要。
C++广义表的创建、输出、取表头、取表尾、广义表深度
10-05
对广义表进行创建，输出，取表头，取表尾，复制广义表，求广义表深度
广义表（C语言实现）
01-08
用C语言实现广义表的存储与遍历，经调试无误，输入的时候是换一行输入,最后要多输右括号,是递归的原因
广义表的建立与遍历
12-16
用Visual C++实现广义表的建立及遍历（ C++程序设计教程（第二版）/钱能著）
十六、广义表的操作算法
11-10
C++数据结构，广义表的操作算法。 在线性表的定义中，要求每个结点都应该是类型相同的基本数据元素。在广义表中放松了我这个约定。每个结点可以属于基本数据类型，也可以属于广义表类型。这种递归定义的结构，展开了非线性结构的天地。
c语言 广义表
m0_66460650的博客
11-28 620
【代码】c语言 广义表。
实现一个广义表
wangiijing的博客
05-22 829
实现一个广义表，实现求广义表的深度，广义表的大小及成员函数
广义表的创建
喜爱兰兰
04-22 5557
广义表是一种链式存储结构，广义表的表示方法有多种，在稍后的博文中我会依次给出各种广义表的算法代码实现。 首先简单的描述一下广义表的数据结构，广义表一般分为列表结点和原子结点。广义表中可以包含另一个广义表，这就使用广义表具有递归性，在下面的广义表创建中，就利用递归的思想进行创建。 对于广义表的表头表尾的理解： 比如广义表:A = (a,(b,c),((d,e,f),g))
c语言广义表,广义表c语言实现.doc
weixin_39661405的博客
05-21 245
广义表c语言实现#includeint Point_0 0;int Point_1 11;void inistak int *tws int i 0;while ! tws int * malloc 2*5+1 *sizeof int ;for i 1;i 10;i++ * tws+i 0; int push int *tws,int i,int *x /*i 0时正向，i 1时反...
广义表的创建，输出，求广义表的深度
sleepwalker1997的博客
04-04 2541
广义表的基础理解请参考     广义表的理解现给出代码和讲解#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define MAXNUM 100 // 输入串的最大长度 char s[MAXNUM];//记录输入串 int index = 0; int level = 0;//记录当前层数 int maxLevel = 0;//记录最大层数 ...
用c++输入广义表建立二叉树
最新发布
03-31
这里给出一个简单的例子，可以通过输入广义表来建立二叉树： ```c #include #include typedef struct Node { char data; struct Node* left; struct Node* right; } Node; Node* createNode(char data) { ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值