广义表相关算法

最新推荐文章于 2024-04-16 21:51:27 发布
最新推荐文章于 2024-04-16 21:51:27 发布
阅读量804 收藏 3
点赞数
分类专栏： algorithm 文章标签： 算法 string null list struct 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/komfanter/article/details/5448430
版权

//Header.h

#ifndef HEADER_H
#define HEADER_H

// 预定义常量和类型
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;

#endif


/***********************************************/

//GList.h

#ifndef GLIST_H
#define GLIST_H

#include <iostream>
#include "Header.h"
using namespace std;

typedef char AtomType;
typedef enum {ATOM, LIST} ElemTag; /* ATOM==0:原子, LIST==1:子表 */
typedef struct GLNode {
    ElemTag tag; /* 公共部分，用于区分原子节点和表节点 */
    union { /* 原子节点和表节点的联合部分 */
        AtomType atom; /* atom是原子节点的值域，AtomType有用户定义 */
        struct {
            struct GLNode *hp, *tp;
        } ptr; /* ptr是表节点的指针域，ptr.hp和ptr.tp分别指向表头和表尾 */
    };
} *GList, GLNode; /* 广义表类型 */

/* 广义表的头尾链表存储的基本操作(11个) */
void InitGList(GList &L);
void CreateGList(GList &L, string S);
void DestroyGList(GList &L);
void CopyGList(GList &T, GList L);
int GListLength(GList L);
int GListDepth(GList L);
Status GListEmpty(GList L);
GList GetHead(GList L);
GList GetTail(GList L);
void InsertFirst_GL(GList &L, GList e);
void DeleteFirst_GL(GList &L, GList &e);
void Traverse_GL(GList L, void (*visit)(AtomType));
void Sever(string &sub, string &hsub);
void Visit(AtomType e);

#endif


/*****************************************************************/

//GList.cpp

/* 广义表的头尾链表存储表示 */
#include <cstdlib>
#include "GList.h"
using namespace std;

/* 创建空的广义表L */
void InitGList(GList &L)
{
    L = NULL;
}

/* 采用头尾链表存储结构，由广义表的书写形式串S创建广义表L。设emp="()" */
void CreateGList(GList &L, string S)
{
    string sub, hsub, emp("()");
    GList p, q;
    if (S == emp)
        L = NULL; /* 创建空表 */
    else {  /* S不是空串 */
        L = (GList)malloc(sizeof(GLNode));
        if (!L)
            exit(OVERFLOW);
        if (S.length() == 1) { /* S为单原子，只会出现在递归调用中 */
            L->tag = ATOM;
            L->atom = S[0]; /* 创建单原子广义表 */
            } else { /* S为表 */
                L->tag = LIST;
                p = L;
                sub =  S.substr(1, S.length() - 2); /* 脱外层括号（去掉第一个字符和最后一个字符）给串sub */
                do { /* 重复建n个子表 */
                    Sever(sub, hsub); /* 从sub中分离出表头串hsub */
                    CreateGList(p->ptr.hp, hsub);
                    q = p;
                    if(!sub.empty()) { /* 表尾不空 */
                        p = (GLNode *)malloc(sizeof(GLNode));
                        if (!p)
                            exit(OVERFLOW);
                        p->tag = LIST;
                        q->ptr.tp = p;
                    }
                } while (!sub.empty());
                q->ptr.tp = NULL;
            }
        }
}

//销毁广义表
void DestroyGList(GList &L)
{
    GList q1, q2;
    if (L) {
        if (L->tag == LIST) { // 删除表节点
            q1 = L->ptr.hp; // q1指向表头
            q2 = L->ptr.tp; // q2指向表尾
            DestroyGList(q1); //销毁表头
            DestroyGList(q2); //销毁表尾
        }
        free(L);
        L = NULL;
    }
}

// 采用头尾链表存储结构，由广义表L复制得到广义表T
void CopyGList(GList &T, GList L)
{
    if (!L) //复制空表
        T = NULL;
    else {
        T = (GList)malloc(sizeof(GLNode)); // 建表节点
        if (!T)
            exit(OVERFLOW);
        T->tag = L->tag;
        if (L->tag == ATOM)
            T->atom = L->atom; // 复制单原子
        else {
            CopyGList(T->ptr.hp, L->ptr.hp);
            CopyGList(T->ptr.tp, L->ptr.tp);
        }
    }
}

// 返回广义表的长度
int GListLength(GList L)
{
    int len = 0;
    while (L) {
        L = L->ptr.tp;
        ++len;
    }
   
    return len;
}

// 采用头尾链表存储结构，求广义表L的深度
int GListDepth(GList L)
{
    int max, dep;
    GList pp;
    if (!L)
        return 1; // 空表深度为1
    if (L->tag == ATOM)
        return 0; // 原子深度为0，只会出现在递归调用中
    for (max = 0, pp = L; pp; pp = pp->ptr.tp) {
        dep = GListDepth(pp->ptr.hp); // 递归求以pp->ptr.hp为头指针的子表深度
        if (dep > max)
            max = dep;
    }

    return max + 1; // 非空表的深度是各元素的深度的最大值加1
}

// 判定广义表是否为空
Status GListEmpty(GList L)
{
    if (!L)
        return TRUE;
    else
        return FALSE;
}

// 生成广义表L的表头元素，返回指向这个元素的指针
GList GetHead(GList L)
{
    GList h, p;
    if (!L) // 空表无表头
        return NULL;
    p = L->ptr.hp; // p指向L的表头元素
    CopyGList(h, p); // 将表头元素复制给h

    return h;
}

// 将广义表L的表尾生成为广义表，返回指向这个新广义表的指针
GList GetTail(GList L)
{
    GList t;
    if (!L) // 空表无表尾
        return NULL;
    CopyGList(t, L->ptr.tp); // 将L的表尾复制给t

    return t;
}

// 初始条件：广义表存在
//操作结果：插入元素e（也可能是子表）作为广义表L的第一个元素（表头)
void InsertFirst_GL(GList &L, GList e)
{
    GList p = (GList)malloc(sizeof(GLNode)); // 生成新节点
    if (!p)
        exit(OVERFLOW);
    p->tag = LIST; // 节点的类型是表
    p->ptr.hp = e; // 表头指向e
    p->ptr.tp = L; // 表尾指向原表
    L = p; // L指向新节点
}

// 初始条件：广义表L存在
// 操作结果：删除广义表L的第一个元素，并用e返回其值
void DeleteFirst_GL(GList &L, GList &e)
{
    GList p = L; // p指向第一个节点
    e = L->ptr.hp; // e指向L的表头
    L = L->ptr.tp; // L指向原L的表尾
    free(p); // 释放第一个节点
}

// 利用递归算法遍历广义表L
void Traverse_GL(GList L, void (*visit)(AtomType))
{
    if (L) { // 不空
        if (L->tag == ATOM) // L为单原子
            visit(L->atom);
        else { // L为广义表
            Traverse_GL(L->ptr.hp, visit); // 递归遍历L的表头
            Traverse_GL(L->ptr.tp, visit); // 递归遍历L的表头
        }
    }
}

void Visit(AtomType e)
{
    cout << e << " ";
}

void Sever(string &sub, string &hsub)
{
    int n = sub.length(), i = 0, k = 0;
    char ch;
    do {
        ch = sub[i];
        switch (ch) {
        case '(': ++k; break;
        case ')': --k; break;
        }
        ++i;
    } while (i <= n && (ch != ',' || k != 0));
    if (i <= n) {
        hsub = sub.substr(0, i - 1); //!
        sub = sub.substr(i, n - i + 1);
    } else {
        hsub = sub;
        sub.clear();
    }
}


/*****************************************************/

//main.cpp


#include "GList.h"
using namespace std;

void process(string s);

int main()
{
    string s;
    string s1("()");
    string s2("((A),((B),C),D)");
    string s3("((A,(B,(C))),(),(((((D),E)))))");
    string s4("(A,(B),(),((C)),D)");
    string s5("((),A,(B))");
    string s6("(((A,(B)),C,(D),((E)),F))");
    process(s1);
    process(s2);
    process(s3);
    process(s4);
    process(s5);
    process(s6);

    return 0;
}

void process(string s)
{
    GList L;
    CreateGList(L, s);
    int len, dep;
    len = GListLength(L);
    dep = GListDepth(L);
    cout << "len=" << len << "/tdep=" << dep << "/t";
    Traverse_GL(L, Visit);
    cout << endl;
}

 

/*********************************************/



komfanter
关注
专栏目录
第九周 项目4 广义表应用
LYS621的博客
10-30 1146
//头文件 typedef char ElemType; typedef struct lnode { int tag; //节点类型标识 union { ElemType data; //原子值 struct lnode *sublist; //指向子表的指针 } val;
广义表算法(数据结构和算法分析)
12-05
广义表的长度，深度，表头，表尾，表头和表尾的连接，两个广义表的连接等相关算法。
第九周项目四广义表算法库
巩凯强的博客
11-01 541
/* * Copyright (c) 2015, 烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称： glist.cpp,main.cpp，glist.h * 作者：巩凯强 * 完成日期：2015年11月1日 * 版本号：codeblocks * * 问题描述: 广义算法库采用程序的多文件组织形式 * 输入描述： 无 * 程序输出： 见运行结果 */ #i
数据结构之自建算法库——广义表
weixin_33676492的博客
10-07 109
本文针对数据结构基础系列网络课程(5)：数组与广义表中第6课时广义表的存储结构及基本运算的实现。 广义算法库采用程序的多文件组织形式，包括两个文件： 　　1.头文件：glist.h，包含定义广义表数据结构的代码、宏定义、要实现算法的函数的声明； #ifndef GLIST_H_INCLUDED #define GLIST_H_IN...
6-3 广义表基本运算算法
wuwuhuai的博客
02-16 853
//广义表基本运算算法 #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include "glnode.h" int GLLength(GLNode *g) //求广义表g的长度 { int n=0; GLNode *g1; g1=g-&gt;val.sublist; //g指向广义表的第一个元素 while (g1!=NUL...
四川大学计算机学院-数据结构与算法分析高分实验报告-引用数使用空间表法广义表存储结构.rar
08-18
本实验报告集中于一个特定的主题——引用数的使用，结合空间表法和广义表的存储结构，这些都是在高级编程和系统设计中至关重要的概念。 首先，让我们详细探讨“引用数”。在计算机科学中，引用数（或称为计数器）...
广义表算法设计
03-21
根据给定的信息，我们可以深入探讨有关广义表的数据结构及其相关算法的设计与实现。广义表作为一种树形数据结构的特殊形式，在计算机科学领域有着广泛的应用。本文将围绕广义表的基本概念、创建方法、深度计算、长度...
数组与广义表的算法的实验报告.pdf
10-14
- 实现广义表算法时，通常采用链式存储，每个节点包含一个元素和指向下一个节点的指针，支持递归结构。 在实验过程中，使用Visual C++实现这些算法，有助于深入理解数组和广义表的内部工作原理，同时认识到算法...
十六、广义表的操作算法
11-10
C++数据结构，广义表的操作算法。 在线性表的定义中，要求每个结点都应该是类型相同的基本数据元素。在广义表中放松了我这个约定。每个结点可以属于基本数据类型，也可以属于广义表类型。这种递归定义的结构，展开了...
广义表建树算法
11-23
严蔚敏数据结构教材中关于广义表建树的算法实现，C语言
广义表算法库及应用
西红柿的博客
11-20 664
问题及代码：/* Copyright (c)2015,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：广义表算法库（1）.cpp 作 者：张耀 完成日期：2015年11月20日 版 本 号：v1.0 问题描述: 1）建立广义表算法库，包括： ① 头文glist.h，定义数据类型，声明函数；
建立广义表的算法
sinat_34927324的博客
12-31 3150
书上的算法实在是难懂，去翻看别人博客上的算法，好像比我的教科书上的要简单一些，但是好像没有处理子表是共享表的功能。于是我用了两个晚上才看懂书上的算法，用我的理解来尽力详细的把建立广义表的全过程还原出来。
【数据结构和算法笔记】：广义表
暮色年华的博客
11-30 269
目录 广义表概念： 表示方法： 括号表示法 子表加匿名表示法 广义表储存结构：​ 广义表的算法设计： 广义表概念： ○广义表（Lists，又称列表）是线性表的推广。 ○线性表定义为n>=0个元素a1,a2,a3,…,an的有限序列。线性表的元素仅限于原子项，原子是作为结构上不可分割的成分，它可以是一个数或一个结构，若放松对表元素的这种限制，容许它们具有其自身结构，这样就产生了广义表的概念。 ○广义表是n (n>=0)个元素a1,a2,a3,…,an的有限序列，其中ai或...
广义表的相关内容与算法分析（重点分析：求广义表深度的递归过程）
最新发布
cx330的博客
04-16 1277
/C语言枚举类型 ATOM=0，LIST=1；//要么为0，要么为1；}atom_htp;//原子结点的值域atom和表结点的指针域htp的联合体体域在这里enum是C语言的枚举：共用体是一种特殊的数据类型，允许在相同的内存位置存储不同的数据类型。我们可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值，共用体提供了一种使用相同的内存位置的有效方式！
数据结构与算法丨广义表
兔子王
10-19 5604
数据结构与算法之列表。
广义表相关总结
weixin_30266885的博客
06-04 251
广义表相关总结 一.定义 广义表是线性表的推广，广义表中每个元素可以是原子，也可以是子表，原子即单个元素，而子表是广义表。我们可以发现，其实python中的数组就是一个广义表，其内元素可以是单个的元素，也可以是一个数组。 二.广义表的长度和深度 1.长度 广义表的长度就是看第一层所含的元素个数 2.深度 广义表的深度是max(每个元素深度) + 1 A=（）：A是一个空表，长度为0，深度为1 B...
【天勤第五章】数组、矩阵与广义表算法总结
Read by heart
08-20 289
一位数组元素移动算法： 设计一个算法，将A中所以非0元素依次移动到A数组的前端（T122.1） 算法1：变量i和j，i指向当前非零元素，j依次指向数组中每一个元素，如果找到非零元素，则使i指向下一个元素，如果i和j不相等说明i所指元素为零元素，将i和j的值交换，j继续遍历下一元素，i则指向了当前最新非零元素。 算法2：双端遍历法。i指向A[0]，j指向A[n-1]，当i<j时做whil...
数据结构学习总结(三）广义表
csdnligao的博客
07-18 1033
1.  广义表 1思想 广义表可以说是线性表的一种泛型定义，它与线性表的主要区别是，广义表的一个数据单元记录的可以是数据本身，也可以记录一个存储数据的线性表。在C++中实现为vector>模板类，而C#中则为数组的数组（形如[datatype][][] variableName的定义）。当然，无论是C++的vector>还是C#的数组的数组，它们也只是实现了广义表的二级深度，而广义表可以是任意
数组与广义表的算法分析及优化
"本资源是一份关于算法分析的PPT，重点关注了数组和广义表。其中提到了算法的时间复杂度分析，特别是针对矩阵操作的情况。同时，详细介绍了数组的概念，包括一维、二维数组以及多维数组的逻辑定义和抽象数据类型。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值