广义表的递归实现 C/C++

于 2023-01-31 11:44:46 发布
阅读量185 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 数据结构 c++ c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyq20010606/article/details/128813740
版权

概论

广义表是一种重要的数据结构，可以看作内置数据类型数组的扩展，即推广数组的定义，可以将另一个数组作为这个数组的元素，再进一步推广，内涵数组中的元素还可以是一个数组，即广义表中的元素可以是一个广义表

如下

数组：[a,b,c,d,e,f,g]

广义表：[a,b,c,[e,[f,g]]]

在python等语言中已经将广义表作为合法数据类型

存储结构

广义表中的元素有两类，一类是广义表，一类是原子，并且一个位置出现的类型是唯一的，所以使用union数据类型来存储元素

同时使用链表类型来构建广义表能节省很大的工作量

typedef struct Glnode           //头尾链表存储结构
{
    ElemTage type;              //用于区存储数据是元素还是子表
    union              //由于有两种数据类型使用共用体来存储相应元素（注意union中的数据只能出现一种）
    {
        char n;                  //元素
        struct Glnode* begin;
    };
    struct Glnode* next;
}*glode;

头尾结点存储（这种办法使得后续构建广义表更加复杂）


typedef struct GLNode
{
    ElemTage type;
    union
    {
        int n;
        struct GLNode* hp，*tp;
    };
}*GList;

初始化广义表

初始化广义表实际就是创建第一个结点，并初始化其中的指针（注意指针在使用和结束以后都要初始化，将指针指向一个安全的区域，否则很可能在后续程序的运行过程中出现内存错误，野指针给cpp的内存操作等提供了很大的便捷性，但是同时也给cpp的内存安全造成很大麻烦）

glode CreatList(glode head,strin S)
{
    glode dim;
    dim = head;
    S->count0 += 1;
    while (S->count0 != S->count-1)
    {
        
        if (S->string[S->count0] <= 'z' && S->string[S->count0] >= 'a')                  //在表中所有元素都是原子时实际上可以直接看作是一个链表的构建
        {
            dim->type = ATOM;
            dim->n = S->string[S->count0];
            if (S->string[S->count0+1] == ')')                                           //这个条件实际是用来判定递归什么时候终止
            {
                dim->next = NULL;                 //同时将最后一个指针指向NULL（实际上这个NULL最好在初始化函数中定义）初始化指针很重要否则cpp中的野指针可能造成很大的麻烦
                return head;
            }
            dim->next = new Glnode;
            dim = dim->next;
            S->count0 += 1;
            continue;
        }
        if (S->string[S->count0] == '(')                                              //在遇到子表时就需要考虑侧枝的构建
        {
            dim->type = LIST;
            dim->begin = new Glnode;
            dim->begin = CreatList(dim->begin, S);                                     //这里通过递归的方法来构建侧链
            if (S->string[S->count0 + 1] == ')')
            {
                dim->next = NULL;
                return head;
            }
            else 
            {
                dim->next = new Glnode;                                                   
                dim = dim->next; 
            }
                                                              //其实把构建侧枝的语句删去，剩下的其实就是链表构建语句
            S->count0 += 1;
            continue;
        }

        S->count0 += 1;
        
    }
    return head;

}

销毁广义表

在数据结构使用结束后应当及时释放内存，初始化指针，否则内存被大量无用数据占用可能会出现内存溢出等问题

void Distorylist(glode head)                        //同样用递归的方法销毁广义表
{
    glode dim;
    dim = head;
    while (dim->next != NULL)
    {
        if (dim->type == ATOM)
        {
            head = head->next;
            free(dim);
            dim = head;
        }
        else if (dim->type == LIST)
        {
            head = head->next;
            Distorylist(dim->begin);               //递归删除支链
            free(dim);
            dim = head;
        }
    }
    if (dim->next == NULL)
    {
        free(dim);
    }
    cout << "广义表成功销毁";
}

广义表深度

即内部最多嵌套的括号的数目

void Deep(glode head)                                      
{
    int count = 1;
    int middle = 0;
    glode dim;
    dim = head;
    while (dim->next != NULL)
    {
        if (dim->type == LIST)
        {
            middle += 1;
            Deep(dim->begin);
        }
        if (middle > count)
        {
            count = middle;
            middle = 1;
        }
        dim = dim->next;
    }
    if (dim->next == NULL)
    {
        if (dim->type == LIST)
        {
            middle += 1;
            Deep(dim->begin);
        }
        if (middle > count)
        {
            count = middle;
        }
    }
    cout << "最深层数" << count << endl;
}

打印广义表

同样使用递归的方法遍历广义表以输出数据

void Print(glode head)
{
    glode dim = head;
    cout << '(';
    while (dim->next != NULL)
    {
        if (dim->type == ATOM)
        {
            cout << dim->n << ',';
            dim = dim->next;
        }
        else if (dim->type == LIST)
        {
            Print(dim->begin);
            dim = dim->next;
            cout << ')';
        }

    }
    if (dim->next == NULL)
    {
        if (dim->type == ATOM)
        {
            cout << dim->n;
            cout << ')';
        }
        if (dim->type == LIST)
        {
            Print(dim->begin);
            cout << ')';
        }
    }
}

完整代码

经过测试能够正常运行

#include<iostream>
#include<stdio.h>
using namespace std;
const int maxsize = 20;

typedef enum{ATOM,LIST}ElemTage;


//以下为辅助函数

typedef struct sqstring                           //使用数据结构串来为广义表导入数据
{
    char string[maxsize];
    int count;                                   //（目前需要的）总数
    int count0 = 0;                                  //起始元素位置
}str, * strin;

strin Initstring()                                //创建并初始化串
{
    strin str1;
    str1 = (strin)malloc(sizeof(str));
    if (!str1)
    {
        cout << "串空间分配失败" << endl;
        abort();
    }
    str1->count = 0;
    str1->count0 = 0;
    return str1;
}
strin Insertstring()                             //一个专门为广义表构建的串输入函数
{
    strin a;
    a = Initstring();
    cout << "请输入广义表序列" << endl;
    char ap;
    cin >> ap;
    while (ap != '#')
    {
        a->string[a->count] = ap;
        a->count += 1;
        cin >> ap;
    }
    return a;
}

void Print(strin S)
{
    int countt = S->count;
    for (int i = 0; i < S->count; i++)
    {
        cout << S->string[i] << " ";
    }
    cout << endl;
}

//广义表的数据类型包括子表和元素，所以使用链表来存储相应结构
//对广义表可以这么理解，如果将所有元素一视同仁则可以看作是一个链表，再分开来看子表实际上相当于在主链上加上侧链

typedef struct Glnode           //头尾链表存储结构
{
    ElemTage type;              //用于区存储数据是元素还是子表
    union                       //由于有两种数据类型使用共用体来存储相应元素
    {
        char n;                  //元素
        struct Glnode* begin;
    };
    struct Glnode* next;
}*glode;
glode InitList()                                   //初始化广义表
{
    glode head;
    head = (glode)malloc(sizeof(Glnode));
    if (!head)                                     //如果初始化失败直接终止程序，弹出错误
    {
        cout << "初始化分配空间失败" << endl;
        abort();
    }
    head->next = NULL;
    return head;
}

void Distorylist(glode head)                        //同样用递归的方法销毁广义表
{
    glode dim;
    dim = head;
    while (dim->next != NULL)
    {
        if (dim->type == ATOM)
        {
            head = head->next;
            free(dim);
            dim = head;
        }
        else if (dim->type == LIST)
        {
            head = head->next;
            Distorylist(dim->begin);               //递归删除支链
            free(dim);
            dim = head;
        }
    }
    if (dim->next == NULL)
    {
        free(dim);
    }
    cout << "广义表成功销毁";
}

glode CreatList(glode head,strin S)
{
    glode dim;
    dim = head;
    S->count0 += 1;
    while (S->count0 != S->count-1)
    {
        
        if (S->string[S->count0] <= 'z' && S->string[S->count0] >= 'a')                  //在表中所有元素都是原子时实际上可以直接看作是一个链表的构建
        {
            dim->type = ATOM;
            dim->n = S->string[S->count0];
            if (S->string[S->count0+1] == ')')                                           //这个条件实际是用来判定递归什么时候终止
            {
                dim->next = NULL;                 //同时将最后一个指针指向NULL（实际上这个NULL最好在初始化函数中定义）初始化指针很重要否则cpp中的野指针可能造成很大的麻烦
                return head;
            }
            dim->next = new Glnode;
            dim = dim->next;
            S->count0 += 1;
            continue;
        }
        if (S->string[S->count0] == '(')                                              //在遇到子表时就需要考虑侧枝的构建
        {
            dim->type = LIST;
            dim->begin = new Glnode;
            dim->begin = CreatList(dim->begin, S);                                     //这里通过递归的方法来构建侧链
            if (S->string[S->count0 + 1] == ')')
            {
                dim->next = NULL;
                return head;
            }
            else 
            {
                dim->next = new Glnode;                                                   
                dim = dim->next; 
            }
                                                              //其实把构建侧枝的语句删去，剩下的其实就是链表构建语句
            S->count0 += 1;
            continue;
        }

        S->count0 += 1;
        
    }
    return head;

}

void Print(glode head)
{
    glode dim = head;
    cout << '(';
    while (dim->next != NULL)
    {
        if (dim->type == ATOM)
        {
            cout << dim->n << ',';
            dim = dim->next;
        }
        else if (dim->type == LIST)
        {
            Print(dim->begin);
            dim = dim->next;
            cout << ')';
        }

    }
    if (dim->next == NULL)
    {
        if (dim->type == ATOM)
        {
            cout << dim->n;
            cout << ')';
        }
        if (dim->type == LIST)
        {
            Print(dim->begin);
            cout << ')';
        }
    }
}

void Deep(glode head)                                      //还未经过测试
{
    int count = 1;
    int middle = 0;
    glode dim;
    dim = head;
    while (dim->next != NULL)
    {
        if (dim->type == LIST)
        {
            middle += 1;
            Deep(dim->begin);
        }
        if (middle > count)
        {
            count = middle;
            middle = 1;
        }
        dim = dim->next;
    }
    if (dim->next == NULL)
    {
        if (dim->type == LIST)
        {
            middle += 1;
            Deep(dim->begin);
        }
        if (middle > count)
        {
            count = middle;
        }
    }
    cout << "最深层数" << count << endl;
}
int main()
{
    glode head;
    head = InitList();
    strin S;
    S = Insertstring();
    Print(S);
    head = CreatList(head, S);
    Print(head);
}

野生的南星（新春限定）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广义表（C语言实现）
01-08
用C语言实现广义表的存储与遍历，经调试无误，输入的时候是换一行输入,最后要多输右括号,是递归的原因
广义表的递归实现
weixin_33849942的博客
04-16 245
广义表是一种数据结构，是线性表的推广。也有人称之为列表（lists）。广泛的用于人工智能等领域的表处理结构。对于广义表，我们需要了解它的结构，通过学习广义表，也加深了对递归的了解。整个广义表都是了利用递归的特性实现的。 （一）首先我们要确定表中每个节点的结构，因为在广义表中有三种不同结构的节点，我们可以使用枚举enum列出我们所用到的结构节点类型。enumType...
递归实现广义表
weixin_33769125的博客
04-17 146
广义表是非线性的结构，是线性表的一种扩展，是有n个元素组成有限序列。由于在表的描述中可以嵌套表，允许表中有表，所以可以通过递归实现广义表。具体实现如下：头文件#pragmaonce //实现广义表的结构 enumType//枚举类型 { HEAD, VALUE, SUB, }; structGeneralizedNode//广义表的结点 { Type...
数据结构5.5_广义表的递归算法
weixin_33938733的博客
02-18 1203
对一些可以用递归算法解决的问题，通常可以先写出问题求解的递归定义。 和第二数学归纳类似，递归定义由基本项和归纳项两部分组成。 递归定义的基本项描述了一个或几个递归过程的终结状态。虽然一个有限的递归可以描述一个无限的计算过程。 但任何实际应用的递归过程，除错误情况外，必定能经过有限层次的递归而终止。 所谓的终结状态，指的是不需要继续递归而可直接求解的状态。 递归定义的归纳项描述...
广义表的存储结构（广义表的递归算法，复制广义表，求广义表的深度）
weixin_30879833的博客
08-21 924
// c5-5.h 广义表的头尾链表存储结构(见图5.16) enum ElemTag{ATOM,LIST}; // ATOM==0：原子，LIST==1：子表 typedef struct GLNode { ElemTag tag; // 公共部分，用于区分原子结点和表结点 union // 原子结点和表结点的联合部分 { AtomType atom; // atom是原子结点...
C++如何实现广义表详解
09-01
广义表是非线性结构，其定义是递归的。那么下面跟着小编一起看看如何用C++实现广义表，有需要的可以参考借鉴。
心希盼 C++ 数据结构 广义表
10-13
心希盼 C++ 数据结构 广义表 递归 详细请看《心希盼 GeneralList.doc》
数据结构 广义表的c++实现(链表)[!注意!描述中有一个bug要修正]
12-22
数据结构中广义表的c++实现,用的是链表,对广义表表达式的格式判断仅有左右括号匹配,忽略空格,不能有连续的空格.实现的功能包括复制,拼接,删除,求深度,判断相等. 所有的功能都用递归实现,写完之后发现头有点大了.. ...
十六、广义表的操作算法
11-10
C++数据结构，广义表的操作算法。 在线性表的定义中，要求每个结点都应该是类型相同的基本数据元素。在广义表中放松了我这个约定。每个结点可以属于基本数据类型，也可以属于广义表类型。这种递归定义的结构，展开了...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
4.3 数据输入输出的概念及在 C 语言中的实现 54 4.4 字符数据的输入输出 54 4.4.1 putchar 函数（字符输出函数） 54 4.4.2 getchar函数（键盘输入函数） 55 4.5 格式输入与输出 55 4.5.1 printf 函数（格式输出函数...
C++广义表的创建、输出、取表头、取表尾、广义表深度
10-05
对广义表进行创建，输出，取表头，取表尾，复制广义表，求广义表深度
广义表的递归算法
趋势创造者-一直在努力，拥抱大海，拥抱浩瀚的天空，探知未来的世界 祗偽妳動訫 Happiness keeps you Sweet
01-22 458
我们可以这样来描述广义表的结点类型： struct node{ int tag; union{ struct node* dlink; ...
广义表——递归入门
poison_biti的博客
09-25 776
“test.cpp” #include using namespace std; #include enum Type { HEAD, SUB, VALUE, }; struct GeneralizedListNode { Type _type; GeneralizedListNode* _next; //union //{ char _value; Generaliz
5.7 递归与广义表的递归
engineer0的博客
12-29 1469
递归 一般来说，递归的执行效率很低，实际应用中能不用就不要用。 递归一般是由基本项和归纳项组成。 基本项：描述了递归过程的一个或几个终结状态（不需要再继续递归而可直接求解的状态）。实际应用中的递归过程必定要经过有限的递归层次到达终结状态。 归纳项：描述如何从当前状态到终结状态的转化。 递归的实质：一个复杂的问题可以分解为若干子问题来处理；其中的某些子问题与原问题有着相同的特征属性；那么就可以运用与原问题相同的分析处理方法。 以汉诺塔为例，原问题是将n个圆盘从x塔座移动到z塔座，可以分解成三个子问
【代码】C++实现广义表及其测试用例
weixin_34224941的博客
04-19 159
广义表是我第一次用递归接触链式的数据结构，其结构如下：HEAD->VAL->VAL->LINK(->HEAD.....)->VAL->......在这里，我们的头结点与link节点是不存储数据的，由此我们便可以定义出节点的数据结构：typedefintDataType; enumNodeType//枚举类型定义...
DS：递归和广义表
Rachel_IS的博客
10-27 430
数据结构第一个卡住的难点出现了——递归???? 四题作业写的很艰难…参考了不少网上的代码 打算利用这几天读一下清华的教材，刷一点题… 毕竟，递归还是特别特别特别特别重要的！！ 递归求组合 设计递归算法，从1、2、3…m中任取k个数的所有组合 #include<iostream> using namespace std; int x[100];//记录已选数 void search(int i...
广义表的C++简单实现
weixin_34380781的博客
04-20 222
广义表是数据结构中非常关键的一部分，它的学习对于树和二叉树有很大的起承作用。那么，它是怎么实现的呢？广义表的实现应用到了一个很熟悉的算法——递归。来看看它的代码吧！#pragmaonce #include<iostream> #include<cassert> usingnamespacestd; enumType { HEAD,//头 ...
广义表求深度
axiqia的专栏
03-25 6047
描述 按表头、表尾的分析方法重写求广义表深度的递归算法   输入 输入一串以'('开始,以')'结束的字符串,并且输入的左右括号必须匹配,如:(),(())..   输出 分别输出按表头、表尾分析方法求广义表深度的结果，每个结果占一行。   输入样例 ((a,b,(c,(d,e),f)),g)   输出样例 4 4 #include #include #inc
数据结构用孩子兄弟表示法创建广义表代码实现
最新发布
05-21
下面是使用孩子兄弟表示法创建广义表的代码实现： ```C++ #include using namespace std; // 定义广义表节点结构体 struct GNode { char data; // 数据域 GNode *firstChild; // 指向第一个子节点的指针 GNode...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值