广义表的C语言实现

最新推荐文章于 2022-09-20 17:27:27 发布
最新推荐文章于 2022-09-20 17:27:27 发布
阅读量1w 收藏 21
点赞数 7
分类专栏： c/c++ 文章标签： 语言 c null merge struct 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dayeshisir/article/details/4406907
版权

广义表的C语言实现

 

最近弄了一下这个广义表，将它的部分操作写了出来，以供大家共同学习，研究。

开发工具：VC6.0

 


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define AtomType char
#define MAXSIZE  1024
#define ElemTag int
#define OK       1
#define ERROR    0


typedef struct GLNode
{
 ElemTag tag;
 union
 {
  AtomType  atom;
  struct GLNode *hp;
 }atom_hp;
    struct GLNode *tp;
}GLNode,*GList;


//功能：分离出广义表中表头部分
//返回：分离后剩下的字符串，不包括逗号
void Disastr(char *s,char *hstr)
{
 int i,j,k,r;
 char rstr[MAXSIZE];
 
 i=j=k=0;
 while(s[i] && (s[i] != ',' || k))
 {
  if (s[i] == '(')  {  k++ ; }        // k 作为括号计数器       
  else if (s[i] == ')') {k--;}
  if (s[i] != ',' || s[i] == ',' && k)
  {
   hstr[j] = s[i];
   i++;
   j++;
  }
 }

 hstr[j] = '/0';
 if (s[i] == ',') {i++;}

 r=0;
 while(s[i])                 // 处理剩余的表尾部分
 {
  rstr[r] = s[i];
  r++;
  i++;
 }
 rstr[r] = '/0';
 strcpy(s,rstr);
}

//功能：根据输入的字符串，建立广义表
//返回：成功则返回建立的广义表的表头，否则，返回NULL
GLNode * GLCreate(char *s)
{
 GLNode *p,*q,*r,*head;
    char substr[MAXSIZE],hstr[MAXSIZE];//rstr[MAXSIZE];
    int len;

 len = strlen(s);
    if ( !strcmp(s,"()") || !len)  { head = NULL;}     // (1) 空表情况
 else if (len == 1)                                      // (2) 原子情况
 {
  head = (GLNode *)malloc(sizeof(GLNode));       // 建立一个新结点
  if (!head)  return NULL;    
  head->tag = 0;                                 // 构造原子结点
  head->atom_hp.atom = *s;
  head->tp = NULL;
 }
    else                                                // (3) 子表情况
 {
  head = (GLNode *)malloc(sizeof(GLNode));
  if (!head) return NULL;
  head->tag = 1;
  p = head;
  s++;
  strncpy(substr,s,len-2);                         // 剥去外层的()
  substr[len-2] = '/0';
  do
  {
   Disastr(substr,hstr);                        // 分离出表头
   r = GLCreate(hstr);
   p->atom_hp.hp = r;                           // 尾插法建表
   q=p;
   len = strlen(substr);
   if (len > 0)
   {
    p = (GLNode*)malloc(sizeof(GLNode));
    if (!p) return NULL;
    p->tag = 1;
    q->tp=p;
   }
  } while (len > 0);
  q->tp=NULL;
 }
 return head;
}

void DisplayList(GList head)
{
 GLNode *p,*q;
   
 if (!head)  return;
 if (head->tag==0)
 {
  printf("%c",head->atom_hp.atom);
  return;
 }
 printf("(");
 if (head)
 {
  do
  {
   p = head->atom_hp.hp;
   q = head->tp;
   while (q && p && p->tag == 0)                //  同一层的原子结点
   {
    printf("%c,",p->atom_hp.atom);
    p = q->atom_hp.hp;
    q = q->tp;
   }
   if (p && !p->tag)                           // 最后一个原子结点
   {
    printf("%c",p->atom_hp.atom);
    break;
   }
   else                                        // 子表情况
   {
    if (!p) printf("()");
    else DisplayList(p);
    if (q)  printf(",");
    head = q;
   }
  } while (head);
  printf(")");
 }
}

//功能：取出广义表的表头部分
//返回：成功则返回广义表的表头，否则，返回空或退出
GList GetHead(GList L)
{
 if (!L)  return (NULL);                    // 空表无表头
 if (L->tag == 0)  exit(0);                 // 原子结点不是表
 else return (L->atom_hp.hp);
}

//功能：取出广义表的表尾部分
//返回：成功返回广义表的表尾部分，否则，返回空或者退出
GList GetTail(GList L)
{
 if (!L) return (NULL);
 if (L->tag == 0) exit(0);
 else return (L->tp);
}

//功能:求出广义表的长度
//返回值:广义表的长度
int Length(GList L)
{
 int k=0;
 GLNode *s;

 if (!L) return 0;                    // 空表的长度为零
 if (L->tag == 0) exit(0);            // 原子不是表
 s=L;
 while(s)                             // 统计表的最上层的长度
 {
  k++;
  s=s->tp;
 }

 return k;
}


//功能：求得广义表的深度
//输入：需求深度的广义表的指针
int Depth(GList L)
{
 int d,max;
 GLNode *s;

 if (!L)  return (1);            // 空表的深度为 1
 if (L->tag==0)  return 0;       // 原子的深度为 0
 s=L;
 max=0;
 while (s)                        // 递归求每个子表深度的最大值
 {
  d = Depth(s->atom_hp.hp);
  if (d > max) max = d;
  s = s->tp;
 }
 return (max+1);                  // 表的深度为子表深度加一
}


//功能：统计原子结点的个数
//输入：需统计的广义表指针
int CountAtom(GList L)
{
 int n1,n2;

 if (!L) return 0;                   // 空表无原子结点
 if (L->tag==0) return 1;            // 原子结点
 n1 = CountAtom(L->atom_hp.hp);     
 n2 = CountAtom(L->tp);
 return (n1+n2);
}

//功能：完成广义表的复制,将res复制到dest中
//返回：成功返回1，否则，返回0
bool CopyList(GList *dest,GList res)
{
 if (!res) {*dest = NULL;return (OK);}

 *dest = (GLNode *)malloc(sizeof(GLNode));
 if (!*dest)  return (ERROR);

 (*dest)->tag = res->tag;
 if (res->tag==0)  (*dest)->atom_hp.atom = res->atom_hp.atom;
    else
    {
  CopyList(&(*dest)->atom_hp.hp,res->atom_hp.hp);
  CopyList(&(*dest)->tp,res->tp);
 }
 return (OK);
}

//功能：合并广义表，如果p为空，则申请空间，将q复制到p中
//例如：((a,b),c) 和(a,b)合并之后为：((a,b),c,a,b)
//算法描述：先找到第一个广义表的最后一个结点，将其链到第二个广义表的首元素即可
void Merge(GList *p,GLNode *q)
{
 GLNode *r;

 if (!q) return;       //  如果复制的是个空表，返回
 if (!p)               // p为空，申请空间
 {
  *p = (GLNode*)malloc(sizeof(GLNode));
  if (!(*p)) return ;
  (*p)->tag = 1;
 }
 else
 {
  if ((*p)->tag)        
  {
   r=*p;
   while(r->tp) r=r->tp;             // 找到最后一个子表的表尾指针
   if (q->tag) r->tp = q;        // 修改表尾指针
  }
 }
}

//功能：类似二叉树的先序遍历遍历广义表L
//eg：例如(a,(b,(c),d))结果为：a,b,c,d
//算法描述：
//L若为原子结点，显示该数据，递归调用遍历后续元素，也即:write(L->atom_hp.atom);PreOrder(L->tp);
//L是子表结点，递归调用遍历该子表，遍历后续元素，也即:PreOrder(L->atom_hp.tp);PreOrder(L->tp);
void PreOrder(GList L)
{
 if (L)
 {
  if (L->tag==0) printf("%c ",L->atom_hp.atom);   // 打印原子结点
  else  PreOrder(L->atom_hp.hp);                  // 往下遍历，类似二叉树中的左子树

  if (L->tp) PreOrder(L->tp);                     // 往右遍历，类似二叉树中的右子树
 }
}

// 判断两个广义表是否相等，相等，返回1，否则，返回0
// 相等的定义：两个广义表具有相同的存储结构，对应的原子结点的数据域也相等
//算法描述：
// 形式：条件
//Equal(p,q) = Equal(p->tp,q->tp) ; p->tag = 0 && q->tag = 0 && p->atom_hp.atom = q->atom_hp.atom
//Equal(p,q) = Equal(p->atom_hp.hp,q->atom_hp.hp) && Equal(p->tp,q->tp) ; p->tag = 1 && q->tag = 1
//Equal(p,q) = false     ; p->tag = 0 && q->tag = 0 p->atom_hp.atom != q->atom_hp.atom 或者 p->tag *p->tag + q->tag*q->tag =1
//Equal(p,q) = false      ; p q 其中之一为NULL
bool Equal(GList p,GList q)
{
 bool flags = true;

 if (!p && q) flags = false;
 if (p && !q) flags = false;
    if (p && q)
 {
  if (p->tag == 0 && q->tag == 0 )
  {
   if (p->atom_hp.atom != q->atom_hp.atom)
    flags = false;
  }
  else if (p->tag == 1 && q->tag == 1)
  {
   flags = Equal(p->atom_hp.hp,q->atom_hp.hp);
  }
  else flags = false;
  if (flags) flags = Equal(p->tp,q->tp);
 }
 return flags;
}

int main()
{
 char s[MAXSIZE],a[MAXSIZE];
 GList head;
    GList L;

 printf("please input a string:");
 scanf("%s",s);
 head = GLCreate(s);
 DisplayList(head);
 printf("/n");

 printf("The Head is:");
    DisplayList(GetHead(head));
    printf("/n");

 printf("The Tail is: ");
 DisplayList(GetTail(head));
 printf("/n");

 printf("The Length is %d/n",Length(head));
 printf("The Depth is %d/n",Depth(head));
 printf("The Atom number is %d/n",CountAtom(head));

 printf("Copy the List:/n");
    CopyList(&L,head);
 DisplayList(L);
 printf("/n");

 printf("Merge the List/n");
 Merge(&L,head);
 DisplayList(L);
 printf("/n");

 printf("PreOrder:");
 PreOrder(head);
 printf("/n");

 printf("input a string:");
 scanf("%s",a);
 L = GLCreate(a);
 DisplayList(L);
 printf(" Eqaul ");
 DisplayList(head);
 printf(":");
 if (Equal(L,head)) printf("yes!/n");
 else printf("no!/n");
 return 0;
}

 

能力有限，如有Bug，还请大家不吝赐教。谢谢！！！

源代码下载：http://download.csdn.net/source/1544416

dayeshisir
关注
  • 7
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构广义表c语言实现（每行都有注释）
12-13
#include #include #define DataType char//定义广义表存储类型为 char //广义表结构 typedef enum{atom,list} NodeTag; typedef struct GLNode{ NodeTag tag;//用以区分原子节点和表节点 union{//c语言共用体 DataType data;//用以存放原子节点的值 struct GLNode *slink;//指向自表的指针 }; struct GLNode *next;
广义表的创建和操作（Ｃ语言）
any_ways的博客
04-08 3093
定义： 广义表是n(n≥0)个元素a1，a2，…，ai，…，an的有限序列。 其中： ①ai--或者是原子或者是一个广义表。 ②广义表通常记作： Ls=( a1，a2，…，ai，…，an)。 ③Ls是广义表的名字，n为它的长度。 ④若ai是广义表，则称它为Ls的子表。 注意： ①广义表通常用圆括号括起来，用逗号分隔其中的元素。 ②为了区分原子和广义表，书写时用大写字母表示广义表，用小写字母表示原子。 ③若广义表Ls非空(n≥1)，则al是Ls的表头，其余元素组成的表(a2，a3，…，a
数据结构之广义表（C语言）
qq_57541265的博客
09-20 4080
本文主要介绍广义表的概念，广义表的构建，销毁，遍历，插入，删除，长度计算，深度计算等操作，在文章的最后有完整的源码
广义表（C语言，傻瓜式实现）
林小默
03-22 4169
广义表广泛应用于人工智能中，不可不谓很重要！ 在学习的过程中，书里没有给出确切的实现方法。而在网上大多数是用c++面向对象来写的。程序冗长。而用C语音写出来的大多有点复杂。所以我结合了一下，写了一个比较容易实现的广义表。 广义表的节点分为两类：一类是原子（atom），另一类是子表（list）。在写节点时候我们需要给节点做标记，以便对节点类型做出判断，然后执行相应的操作。 下面是广义表的一个简
广义表-----C语言
weixin_42310549的博客
06-23 890
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;typedef enum {atom, list} NodeTag;  //atom = 0, 表示原子; list = 1, 表示子表typedef char DataType;typedef struct GLNode {    NodeTag tag;   //区分原子结点和表结点    uni...
广义表（Ｃ语言实现）.rar
08-04
广义表的 部分功能实现，比如，创建，显示，取出表头，表尾等
广义表（C语言实现）
01-08
用C语言实现广义表的存储与遍历，经调试无误，输入的时候是换一行输入,最后要多输右括号,是递归的原因
广义表复杂功能实现
08-04
根据输入广义表串进行智能解析，把广义表存储到内存中，然后可根据存储的广义表以广义表的格式进行打印。 可直接下代码编译生成可执行程序。 此代码中已经包含了串操作的全部功能，下载此代码后不需要重复下载串功能...
C语言实现广义表的头尾链表存储表示
06-03
C语言实现广义表的头尾链表存储表示
广义表数据结构ADT实现代码
12-02
广义表数据结构ADT实现代码，符合ADT要求，头文件放ADT函数接口定义和存储结构定义，cpp文件放实现，在控制台查看输出，C语言实现，功能多，注释多，轻松易懂，可用来初学或者作业完成
广义表的头尾链表存储结构实现（C语言
05-18
用头尾链表存储结构实现广义表的创建，输出，查找，统计广义表的长度、深度、原子个数。（递归算法)
C++如何实现广义表详解
09-01
广义表是非线性结构，其定义是递归的。那么下面跟着小编一起看看如何用C++实现广义表，有需要的可以参考借鉴。
广义表抽象数据结构的实现
10-05
这是关于广义表数据结构的实现，其中有很多功能的实现。
广义表（ADT实现）
07-11
严蔚敏数据结构设计性实验，抽象数据类型广义表的实现。包括广义表的创建，删除结点，插入，计算原子个数，长度，深度，销毁广义表等基本操作，C语言代码版
C++广义表的创建、输出、取表头、取表尾、广义表深度
10-05
对广义表进行创建，输出，取表头，取表尾，复制广义表，求广义表深度
广义表的创建，长度，深度和元素个数详解（C实现）
m0_61395860的博客
02-16 2069
一、广义表操作思路 1.创建思路 typedef struct node { int tag; //用于识别单元素与子表 union //大括号中多选一 { char data; //单元素 struct node *child; //子表 }val; struct node *next; //指向下一个元素 }GLNode; 由图可看出，tag=1时，为子表的头结点，tag=0时，为子表元素；并且头结点有一个指向孩子结点的child指针，元素结点有
c语言广义表,广义表c语言实现.doc
weixin_39661405的博客
05-21 207
广义表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时反...
广义表详解（C语言版）
qq_44075108的博客
04-05 6892
广义表详解（C语言版）
c语言用广义表存储兴趣爱好,广义表的C语言实现
weixin_29737443的博客
05-17 456
广义表的C语言实现最近弄了一下这个广义表，将它的部分操作写了出来，以供大家共同学习，研究。开发工具：VC6.0#include #include #include #define AtomType char#define MAXSIZE 1024#define ElemTag int#define OK 1#define ERROR 0typedef struct GLNode...
数据结构C语言广义表代码实现
最新发布
08-24
广义表是一种常用的数据结构，它可以表示多层次的嵌套结构。在C语言中，可以使用链表来实现广义表。 以下是一个简单的广义表的C语言代码实现： ```c #include <stdio.h> #include <stdlib.h> // 结点的数据类型定义 typedef struct Node { char data; // 数据域，存储广义表的元素 struct Node* next; // 指针域，指向下一个结点 struct Node* sublist; // 子表指针，指向子表的头结点 } Node; // 创建结点 Node* createNode(char data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; newNode->sublist = NULL; return newNode; } // 插入结点到广义表中 void insert(Node** head, char data) { if (*head == NULL) { *head = createNode(data); return; } Node* current = *head; while (current->next != NULL) { current = current->next; } current->next = createNode(data); } // 插入子表到广义表中 void insertSublist(Node** head, Node* sublist) { if (*head == NULL) { *head = sublist; return; } Node* current = *head; while (current->next != NULL) { current = current->next; } current->next = sublist; } // 打印广义表 void printList(Node* head) { if (head == NULL) { printf("()"); return; } printf("("); Node* current = head; while (current != NULL) { if (current->sublist == NULL) { printf("%c", current->data); } else { printList(current->sublist); } if (current->next != NULL) { printf(", "); } current = current->next; } printf(")"); } // 释放广义表的内存 void freeList(Node** head) { Node* current = *head; while (current != NULL) { Node* temp = current; current = current->next; if (temp->sublist != NULL) { freeList(&temp->sublist); } free(temp); } *head = NULL; } int main() { Node* list = NULL; // 插入元素到广义表中 insert(&list, 'A'); insert(&list, 'B'); insert(&list, 'C'); // 创建子表并插入到广义表中 Node* sublist = createNode('D'); insert(&sublist->sublist, 'E'); insert(&sublist->sublist, 'F'); insertSublist(&list, sublist); // 打印广义表 printList(list); // 释放广义表的内存 freeList(&list); return 0; } ``` 这段代码实现了一个简单的广义表，可以通过调用`insert`和`insertSublist`函数插入元素和子表，并通过`printList`函数打印整个广义表。记得在程序结束时，调用`freeList`函数释放广义表的内存。 注意：这只是一个简单的实现示例，实际应用中可能需要根据具体需求进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值