【实例】复制广义表

最新推荐文章于 2021-12-06 21:17:30 发布
最新推荐文章于 2021-12-06 21:17:30 发布
阅读量784 收藏 6
点赞数 2
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44898710/article/details/107029687
版权

设广义表采用头链和尾链存储结构，编写把广义表la复制到另一个广义表的函数

广义表的存储结构分为：
  1. 头链和尾链存储结构
  2. 原子和子表存储结构

本文核心代码块：

注意：Glist为表的指针，GListNode,GLNode为实体
结构体如下：

//复制广义表，l1复制给l2
void copyGList(GList *l2, GList l1)
{
    if (!l1)
        *l2 = NULL;       //复制空表
    else
    {
        *l2 = (GList)malloc(sizeof(GListNode));
        (*l2)->tag = l1->tag;  //复制原子/子表标记位
        if (l1->tag == 0)
            (*l2)->val.atom = l1->val.atom;
        else
        {
            copyGList(&((*l2)->val.sublist.head), l1->val.sublist.head);
            copyGList(&((*l2)->val.sublist.tail), l1->val.sublist.tail);
        }
    }
}

实现过程：

首先我们创建一个广义表，采用头链和尾链存储结构，任何一个广义表都可以分解为表头和表尾，因此创建广义表的时候也可以分解为创建表头广义表和表尾广义表
在此之前我们得到一个字符串，即一个广义表，先把他分成表头(hstr)和表尾(str)，分别用字符串表示，代码如下：
//得到字符串形式的表头和表尾
void decomposeStr(char str[], char hstr[])
{
    int n = strlen(str);
    int i, j;
    int tag = 0;  //标记左括号和右括号匹配信息，如果左括号数目等于右括号数目，则遍历到的左右括号数目相等
    for (i = 0; i < n; i++)           //搜索最外一层的第一个逗号
    {
        if (str[i] == ','&& tag == 1)  // ==1表示遍历到的左括号多一个，即最外层第一个逗号
            break;
        if (str[i] == '(')
            tag++;
        if (str[i] == ')')
            tag--;
    }//搜索到之后，i就是第一个逗号的下标值
    //如果表尾部分非空
    if (i < n&&str[i] == ',')
    {
        for (j = 0; j < i - 1; j++)    //表头字符串，在第一个逗号之前，即i-1
            hstr[j] = str[j + 1];
        hstr[j] = '\0';               //表头结束
        if (str[i] == ',')
        i++;                          //i越过第一个逗号
        str[0] = '(';
        for (j = 1; i < n - 1; j++, i++)
            str[j] = str[i];
        str[j] = ')';
        str[++j] = '\0';   //表尾结束
    }
    else            //表尾为空表
    {
        str++;      //略过最外层左括号
        strcpy_s(hstr, n+1, str);       //strcpy_s函数特性，中间参数是原字符串长度加一
        hstr[n - 2] = '\0';
        str--;
        strcpy(str,"()");     //表尾无论在那种情况下都是一种广义表，所以此处用空表
    }
    /*printf("表头：%s\n", hstr);
    printf("表尾：%s\n", str);*/
}

至此我们得到了广义表的表头与表尾，开始创建广义表，利用递归不断地将字符串分割成表头和表尾来创建子表，看代码：

//创建广义表
GListNode *createGList(char str[])
{
    GLNode *head;
    int len = strlen(str);
    if (strcmp(str, "()") == 0)      //是空广义表
        head = NULL;
    else if (len == 1)               //广义表只有一个原子
    {
        head = (GLNode*)malloc(sizeof(GLNode));
        head->tag = 0;
        head->val.atom = str[0];
    }
    else                             //广义表不止一个原子
    {
        head = (GLNode*)malloc(sizeof(GLNode));
        head->tag = 1;
        char hstr[200];
        decomposeStr(str, hstr);     //将广义表分解为表头和表尾
        head->val.sublist.head = createGList(hstr);  //创建表头广义表
        if (strcmp(str, "()") != 0)   //如果表尾广义表不为空，创建表尾广义表
            head->val.sublist.tail = createGList(str);
        else
            head->val.sublist.tail = NULL;
    }
    return head;
}
为了验证是否复制成功，在这里输出目的广义表的长度，深度

完整测试代码如下：

头文件：《GLNode》

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef char DataType;
typedef struct GListNode
{
    int tag;     //为1表示原子，0表示子表
    union
    {
        DataType atom;
        struct {
            struct GListNode *head;
            struct GListNode *tail;
        }sublist;
    }val;
}GLNode,*GList;
//得到字符串形式的表头和表尾
void decomposeStr(char str[], char hstr[])
{
    int n = strlen(str);
    int i, j;
    int tag = 0;  //标记左括号和右括号匹配信息，如果左括号数目等于右括号数目，则遍历到的左右括号数目相等
    for (i = 0; i < n; i++)           //搜索最外一层的第一个逗号
    {
        if (str[i] == ','&& tag == 1)  // ==1表示遍历到的左括号多一个，即最外层第一个逗号
            break;
        if (str[i] == '(')
            tag++;
        if (str[i] == ')')
            tag--;
    }//搜索到之后，i就是第一个逗号的下标值
    //如果表尾部分非空
    if (i < n&&str[i] == ',')
    {
        for (j = 0; j < i - 1; j++)    //表头字符串，在第一个逗号之前，即i-1
            hstr[j] = str[j + 1];
        hstr[j] = '\0';               //表头结束
        if (str[i] == ',')
        i++;                          //i越过第一个逗号
        str[0] = '(';
        for (j = 1; i < n - 1; j++, i++)
            str[j] = str[i];
        str[j] = ')';
        str[++j] = '\0';   //表尾结束
    }
    else            //表尾为空表
    {
        str++;      //略过最外层左括号
        strcpy_s(hstr, n+1, str);       //strcpy函数特性，中间参数是原字符串长度加一
        hstr[n - 2] = '\0';
        str--;
        strcpy(str,"()");     //表尾无论在那种情况下都是一种广义表，所以此处用空表
    }
    /*printf("表头：%s\n", hstr);
    printf("表尾：%s\n", str);*/
}
//创建广义表
GListNode *createGList(char str[])
{
    GLNode *head;
    int len = strlen(str);
    if (strcmp(str, "()") == 0)      //是空广义表
        head = NULL;
    else if (len == 1)               //广义表只有一个原子
    {
        head = (GLNode*)malloc(sizeof(GLNode));
        head->tag = 0;
        head->val.atom = str[0];
    }
    else                             //广义表不止一个原子
    {
        head = (GLNode*)malloc(sizeof(GLNode));
        head->tag = 1;
        char hstr[200];
        decomposeStr(str, hstr);     //将广义表分解为表头和表尾
        head->val.sublist.head = createGList(hstr);  //创建表头广义表
        if (strcmp(str, "()") != 0)   //如果表尾广义表不为空，创建表尾广义表
            head->val.sublist.tail = createGList(str);
        else
            head->val.sublist.tail = NULL;
    }
    return head;
}
//复制广义表，l1复制给l2
void copyGList(GList *l2, GList l1)
{
    if (!l1)
        *l2 = NULL;       //复制空表
    else
    {
        *l2 = (GList)malloc(sizeof(GListNode));
        (*l2)->tag = l1->tag;  //复制原子/子表标记位
        if (l1->tag == 0)
            (*l2)->val.atom = l1->val.atom;
        else
        {
            copyGList(&((*l2)->val.sublist.head), l1->val.sublist.head);
            copyGList(&((*l2)->val.sublist.tail), l1->val.sublist.tail);
        }
    }
}
//广义表的深度——对表尾循环，一层一层拆开
int GListDepth(GListNode *head)
{
    GListNode *p = head;
    //两个递归出口
    if (head == NULL)      //空表深度为1
        return 1;
    if (head->tag == 0)    //原子深度
        return 0;
    int max;
    for (max = 0; p != NULL;p = p->val.sublist.tail)
    {
        int dep = GListDepth(p->val.sublist.head);
        if (dep > max)
            max = dep;
    }
    return max + 1;
}
//广义表的长度
int GListLength(GListNode *head)
{
    if (head == NULL)
        return 0;
    int number = 0;
    GLNode *p = head;
    while (p != NULL)
    {
        number++;
        p = p->val.sublist.tail;   //一层一层剥开表尾
    }
    return number;
}

主函数:《main.c》

int main()
{
    char str[200];
    gets_s(str);
    char brr[200];
    printf("原广义表：%s\n", str);
    GListNode *h1;
    h1 = createGList(str);
    GListNode *h2 = (GListNode*)malloc(sizeof(GListNode));
    copyGList(&h2,h1);
    printf("\nh2 的深度为：%d\n", GListDepth(h2));
    printf("h2 的长度为：%d\n", GListLength(h2));
    system("pause");
    return 0;
}

代码结束

测试结果：

测试一

测试二

代码编译器：Visual Studio 2017
ok

Chaim16
关注
专栏目录
微分几何入门与广义相对论：主丛上的基本矢量场
AI天才研究院
07-11 255
微分几何入门与广义相对论：主丛上的基本矢量场 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 关键词：微分几何，广义相对论，主丛，基本矢量场，数学模型，算法实现，物理应用 1. 背景介绍
广义表的复制
11-18
复制一个广义表的程序，主要是在自己定义了一个广义表以后，用程序的形式将它复制，没有递归
复制广义表
野狼
12-25 1037
根据广义表的信息和结构，将一个广义表复制到另外的一个广义表中 typedef enum{ ATOM,LIST; }ElemTag; //ATOM==0:原子，LIST==1:字表 typedef struct GLNODE{ ElemTag tag; //公共部分，用于区分原子节点和表结点 union{ AtomType atom; //at
广义表-求广义表深度，建立广义表，复制广义表
lingxw的博客
11-12 1588
广义表-求广义表深度，建立广义表，复制广义表 例： 广义表（a,(a,b),d,e,((i,j),k)) 求广义表的长度和深度 长度为5，深度为3 长度：有效逗号个数+1 深度：有效括号个数 求广义表的深度 广义表的深度指的是广义表中括弧的重数； 空表的深度为1，因为有一对括弧； 原子的深度为0； 解题思路： 1）遍历该广义表各个数据元素，求该元素的深度。如果该元素是原子，则返回深度0；如果该元素是子表，则遍历该子表的深度； 2）递归的出口状态，或者叫做终结状态：当遍历数据元素为原子时返回0，当遍历数
广义表的拷贝 遍历 删除 置换（替换） 具体实现代码
牛大春の博客
10-24 396
直接上代码了… #include<iostream> #include<cstring> #include<math.h> #include<stdlib.h> using namespace std; enum GlistNodeType {ATOM,LIST }; template <class T > struct GlistNode { GlistNodeType type;//节点类型 union{ T data ;
数据结构30：广义表的复制
weixin_30662109的博客
05-15 232
对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。递归的出口有两个： 如果当前遍历的数据元素为空表，则直接返回空表。 如果当前遍历的...
自监督描述符在图像复制检测中的应用
我们通过改变架构和训练目标来将这种方法适应于复制检测任务，包括从实例匹配文献中引入的池化运算符，并将对比学习适应于组合图像的增强。我们的方法依赖于熵正则化项，促进描述符向量之间的一致分离，并且我们证明...
自蒸馏嵌入和对比生成用于广义零样本学习
93060En-Compactness: 自蒸馏嵌入和对比生成用于广义零样本学习0Xia Kong 1 Zuodong Gao 1 Xiaofan Li 1 Ming Hong 10Jun Liu 2 Chengjie Wang 2 Yuan Xie 3 † Yanyun Qu 1 †01 厦门...
GRF：用于3D表示和绘制的广义辐射场
15182看到类别GRF看不见类别新颖的视图渲染GRF：学习一种用于3D表示和绘制的广义辐射场亚历克斯·崔维西克加州大学圣地亚哥分校、牛津大学atrevithick@ucsd.edu柏杨香港理工大学邮箱：bo. polyu.edu.hk摘要我们提出...
广义无源域自适应方法的目标是在适应目标领域时保持源领域的性能
8978广义无源域自适应杨世奇，王亚星，王亚星，2*，王亚星，2*，王亚星，3华为麒麟解决方案，中国{syang，yaxing，joost，lherranz}@ cvc.uab.es，jui. huawei.com摘要领域自适应（DA）的目的是将从源领域学习到的...
广义表链表表示的复制删除比较运算的非递归实现(c++)
naturerun的博客
12-06 399
广义表链表表示的删除： 从广义表附加头节点开始，逐一分离表头元素，是原子项就直接删除,是子表附加头节点则暂不删除，直接进入子表，再分离表头元素，然后用相同的方法删除，子表删除完成后向上回溯，继续删除上一层子表，如此不断进行直到整个广义表被删除为止 代码（C++） #include "stdafx.h" #include <iostream> #include <vector> #include<string> using namespace std; struc
广义表的复制及C语言代码实现
数据结构和算法教程（C语言版）
03-17 704
对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。 所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。 递归的出口有两个： 如果当前遍历的数据元素为空表，则直接返回空表。 如果当前遍历的...
广义表的java实现_广义表的复制详解（含C语言代码实现）
weixin_36429440的博客
02-28 193
对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。递归的出口有两个：如果当前遍历的数据元素为空表，则直接返回空表。如果当前遍历的数据元素为该...
数据结构（10）广义表的介绍与代码实现（c语言）
it_is_me_a的博客
08-20 6172
概念 广义表是线性表的推广。广义表GL = (a1,a2,a3…,an)，如果ai是单个数据元素，则称ai是广义表的原子；如果ai也是一个广义表，则称ai是广义表的子表。在广义表中要求各原子具有相同的类型，但允许各子表具有不同的结构。 举一个广义表的例子：D=((a,b), ( c), d, ((e,f),g))，这个广义表D有4个元素，其中4表示广义表的长度。D中所包含括号的最大层数称为广义表的...
广义表的存储结构（广义表的递归算法，复制广义表，求广义表的深度）
weixin_30879833的博客
08-21 950
// c5-5.h 广义表的头尾链表存储结构(见图5.16) enum ElemTag{ATOM,LIST}; // ATOM==0：原子，LIST==1：子表 typedef struct GLNode { ElemTag tag; // 公共部分，用于区分原子结点和表结点 union // 原子结点和表结点的联合部分 { AtomType atom; // atom是原子结点...
广义表的读取和输出,树的拷贝及比较的实现
皓月的博客
05-23 1344
1. 树采用链表的形式保存，每一个节点设计成一个数据域和n个指针域， n为树的度，为了方便固定为树的最大度，但是有点浪费空间。 2. 实现的函数使用到栈来处理，遍历树时采用递归的方法。 //tree.h #include #define DEGREE 3 typedef struct Node{     char ch;     struct Node * link[
广义表的C语言实现
热门推荐
dayeshisir的专栏
08-04 1万+
广义表的C语言实现 最近弄了一下这个广义表，将它的部分操作写了出来，以供大家共同学习，研究。开发工具：VC6.0 #include #include #include #define AtomType char#define MAXSIZE  1024#define ElemTag int#define OK       1#define ERROR    0typed
数据结构_数组与广义表_广义表的建立、遍历、复制、求深度
Dreamer Thinker Doer
10-27 9750
由一个存储着广义表信息的字符串建立一个广义表，并对其进行复制，求深度。 递归真是奇妙无穷啊，有些看似很复杂的东西只要找到规律就能进行递归求解。让我不得不对那些发现规律利用规律创造新事物的人肃然起敬。其实在众多美丽的事物中，人的思想也是很美丽的，那些数学家，哲学家能在意识的世界创造出瑰丽的奇观，让无数后人敬仰不已，好多人不理解数学家和哲学家，认为他们太古板太疯狂，其实他们是被物质世界蒙蔽了双眼
广义表及其实现
qingdou_aixuexi的博客
04-19 791
一，定义 广义表是一种非线性的结构，是线性表的一种扩展，是有n个元素组成的一种有限序列。 它是递归的，因为在表的描述中有得到表，允许表中有表。 二，实例 A = () B = (a,b) C = (a,b,(c,d)) D = (a,b,(c,d),(e,(f),h)) E = (((),())) 三，图解 四，代码实现
数据结构：广义表的特性和递归性质分析
其次，广义表支持共享机制，一个广义表可以引用另一个广义表的部分或全部，而不是复制它。通过表名引用，可以节省内存并简化数据管理。这种特性在实现数据结构如链表、树或图时十分关键。 再者，广义表可以是递归的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值