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

最新推荐文章于 2024-04-16 21:51:27 发布
最新推荐文章于 2024-04-16 21:51:27 发布
阅读量237 收藏 2
点赞数
分类专栏： 算法与数据结构 文章标签： 数据结构 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);
}

c/c++：数据结构——广义表的应用
走向CTO的路上...
11-29 1074
每个节点包含一个数据元素、一个指向第一个子节点的指针（child）、一个指向下一个兄弟节点的指针（sibling）。广义表是一种扩展了线性表的数据结构，可以存储多层次、多叉的数据。下面是一个示例的C++代码，实现了广义表的建立、查找、输出、取表头和取表尾以及求深度等功能。广义表的概念在计算机科学中非常常见，因此有很多产品和库在使用广义表或类似的数据结构。广义表的应用场景非常广泛，特别适用于需要处理层次结构数据的场景。要求实现的广义表的建立、查找、输出、取表头和取表尾以及求深度等。(6)求广义表的深度。
广义表的递归实现
如风
05-24 3743
广义表是一种数据结构，是线性表的推广。也有人称之为列表（lists）。广泛的用于人工智能等领域的表处理结构。 对于广义表，我们需要了解它的结构，通过学习广义表，也加深了对递归的了解。整个广义表都是了利用递归的特性实现的。650) this.width=650;" src="http://s5.51cto.com/wyfs02/M00/7F/12/wKiom1cR9nXi69W3AAAgWvMXs1
广义表（C语言实现）
01-08
用C语言实现广义表的存储与遍历，经调试无误，输入的时候是换一行输入,最后要多输右括号,是递归的原因
数据结构5.5_广义表的递归算法
weixin_33938733的博客
02-18 1243
对一些可以用递归算法解决的问题，通常可以先写出问题求解的递归定义。 和第二数学归纳类似，递归定义由基本项和归纳项两部分组成。 递归定义的基本项描述了一个或几个递归过程的终结状态。虽然一个有限的递归可以描述一个无限的计算过程。 但任何实际应用的递归过程，除错误情况外，必定能经过有限层次的递归而终止。 所谓的终结状态，指的是不需要继续递归而可直接求解的状态。 递归定义的归纳项描述...
广义表的存储结构（广义表的递归算法，复制广义表，求广义表的深度）
weixin_30879833的博客
08-21 976
// c5-5.h 广义表的头尾链表存储结构(见图5.16) enum ElemTag{ATOM,LIST}; // ATOM==0：原子，LIST==1：子表 typedef struct GLNode { ElemTag tag; // 公共部分，用于区分原子结点和表结点 union // 原子结点和表结点的联合部分 { AtomType atom; // atom是原子结点...
广义表的递归算法
趋势创造者-一直在努力，拥抱大海，拥抱浩瀚的天空，探知未来的世界 祗偽妳動訫 Happiness keeps you Sweet
01-22 497
我们可以这样来描述广义表的结点类型： struct node{ int tag; union{ struct node* dlink; ...
使用c/c++完成的广义表基本操做、广义表类.rar
01-12
广义表在C++和C编程中被广泛使用，特别是在实现复杂算法和数据操作时。 广义表是一种链式结构，它可以包含不同类型的数据元素，甚至可以嵌套其他广义表。这种特性使得广义表非常适合处理递归和树状结构的问题。在...
C++如何实现广义表详解
09-01
总之，C++实现广义表的关键在于理解其递归结构，并通过适当的数据结构（如节点结构体和广义表类）来表示这种结构。同时，实现广义表的各种操作，如创建、打印、查找、修改等，是理解和应用广义表的重要部分。在实际...
广义表实现源码(C++、C)
03-12
广义表的实现通常涉及到两种主要的编程语言：C++和C。在这两个语言中，我们可以使用不同的数据结构来模拟广义表，如指针和引用。 在C++中，广义表的实现可能基于类，利用面向对象特性。我们首先定义一个基类`...
递归实现广义表
weixin_33769125的博客
04-17 168
广义表是非线性的结构，是线性表的一种扩展，是有n个元素组成有限序列。由于在表的描述中可以嵌套表，允许表中有表，所以可以通过递归实现广义表。具体实现如下：头文件#pragmaonce //实现广义表的结构 enumType//枚举类型 { HEAD, VALUE, SUB, }; structGeneralizedNode//广义表的结点 { Type...
广义表——递归入门
poison_biti的博客
09-25 803
“test.cpp” #include using namespace std; #include enum Type { HEAD, SUB, VALUE, }; struct GeneralizedListNode { Type _type; GeneralizedListNode* _next; //union //{ char _value; Generaliz
广义表的相关内容与算法分析（重点分析：求广义表深度的递归过程）
最新发布
cx330的博客
04-16 1374
/C语言枚举类型 ATOM=0，LIST=1；//要么为0，要么为1；}atom_htp;//原子结点的值域atom和表结点的指针域htp的联合体体域在这里enum是C语言的枚举：共用体是一种特殊的数据类型，允许在相同的内存位置存储不同的数据类型。我们可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值，共用体提供了一种使用相同的内存位置的有效方式！
5.7 递归与广义表的递归
engineer0的博客
12-29 1621
递归 一般来说，递归的执行效率很低，实际应用中能不用就不要用。 递归一般是由基本项和归纳项组成。 基本项：描述了递归过程的一个或几个终结状态（不需要再继续递归而可直接求解的状态）。实际应用中的递归过程必定要经过有限的递归层次到达终结状态。 归纳项：描述如何从当前状态到终结状态的转化。 递归的实质：一个复杂的问题可以分解为若干子问题来处理；其中的某些子问题与原问题有着相同的特征属性；那么就可以运用与原问题相同的分析处理方法。 以汉诺塔为例，原问题是将n个圆盘从x塔座移动到z塔座，可以分解成三个子问
【代码】C++实现广义表及其测试用例
weixin_34224941的博客
04-19 174
广义表是我第一次用递归接触链式的数据结构，其结构如下：HEAD->VAL->VAL->LINK(->HEAD.....)->VAL->......在这里，我们的头结点与link节点是不存储数据的，由此我们便可以定义出节点的数据结构：typedefintDataType; enumNodeType//枚举类型定义...
广义表 —— C++实现
bit16Girl的博客
11-28 1326
广 义 表 ——C++ 实现 苦b南信带带二计软院本科生开始做数据结构作业辣！！ 题目：编程实现 广 义 表: A=(), B=(a,(b,c,d)) C=(e),D=(A,B,C,f) (1)复制广义表B (2)求广义表D深度。 欧K，开始应付作业8 什么？应付作业？那怎么能对得起大学辛苦的栽培！？还有严蔚敏奶奶辛苦写的课本！？ 于是决定搞个 带 工 程 那么首先考虑的是从用户（...
广义表C++实现
05-09
实现广义表的创建，求广义表的深度，输出广义表
DS：递归和广义表
Rachel_IS的博客
10-27 504
数据结构第一个卡住的难点出现了——递归???? 四题作业写的很艰难…参考了不少网上的代码 打算利用这几天读一下清华的教材，刷一点题… 毕竟，递归还是特别特别特别特别重要的！！ 递归求组合 设计递归算法，从1、2、3…m中任取k个数的所有组合 #include<iostream> using namespace std; int x[100];//记录已选数 void search(int i...
广义表的C++简单实现
weixin_34380781的博客
04-20 247
广义表是数据结构中非常关键的一部分，它的学习对于树和二叉树有很大的起承作用。那么，它是怎么实现的呢？广义表的实现应用到了一个很熟悉的算法——递归。来看看它的代码吧！#pragmaonce #include<iostream> #include<cassert> usingnamespacestd; enumType { HEAD,//头 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值