数据结构之广义表（C语言）

已于 2022-09-21 08:44:04 修改
阅读量4.3k 收藏 106
点赞数 10
分类专栏： C语言 数据结构 文章标签： 数据结构 算法 c语言
于 2022-09-20 17:27:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57541265/article/details/126906101
版权

文章目录
1、广义表的定义
2、广义表的存储结构
3、代码结构描述
5、广义表的各类操作
6、代码测试
7、完整代码

作者建议：为了方便读者能够更加理解代码实现，建议各位读者在看代码的时候可以参考广义表的内存模型。

一，广义表的定义

  广义表是线性表的推广，也被称为列表（lists）。
广义表一般记作：
LS=（a1，a2，a3，…，a n）
　　LS是表的名称，n是表的长度。在线性表的定义中，a i （1<=i<=n）只能限于单个元素，但是在广义表中a i 可以是 单个元素，也可以是广义表，分别称为广义表LS的原子和子表。 当广义表非空时，第一个元素（a1）被称为表头，其余元素（a2，a3，…，a n）被称为子表。

二，广义表的存储结构

  由于广义表的数据元素可以是原子和子表，因此很难用顺序存储结构来表示，通常采用链式存储结构，每个数据元素可以用一个结点来表示。
 由此我们需要２种数据结构来表示结点：一个是表结点，用来表示列表，另一个是原子结点，用来表示原子。
在这里插入图片描述
在这里插入图片描述

三，代码结构描述


//节点类型枚举
typedef enum
{
    ATOM, //原子类型
    LIST  //列表类型
} ElemTag;
//表数据结构
struct LS_Data
{
    int data;    //存储数据
    char number; //存储编号
};
typedef struct LS_Data LS_Data;
//表结点结构
struct LS_Node
{
    ElemTag Tag; //结点类型标识
    union
    {
        LS_Data value;
        struct
        {
            struct LS_Node *hp; //表头指针
            struct LS_Node *tp; //表尾指针
        } ptr;
    };
};

typedef struct LS_Node LS_Node;
//广义表
struct Mul_Lists
{
    LS_Node *headPtr;//头结点
    unsigned int len;//表的长度
    LS_Node *lastNode;//末尾节点
};
typedef struct Mul_Lists Mul_Lists;

下面我们以广义表LS=（a，b，（c，d），e，f）为例。
下面是该广义表的内存模型：
在这里插入图片描述
空的方框表示列表结点

3.1， 广义表所需的操作


//返回一个空的广义表
Mul_Lists GetMulLists(void);
//构造广义表
void InitMulLists(Mul_Lists *LS, char *Num, LS_Data Data[], int Len);
//广义表是否为空
bool Empty(Mul_Lists *LS);
//销毁广义表
void Destroy(Mul_Lists *LS);
//获取广义表的长度
unsigned int Length(Mul_Lists *LS);
//获取广义表的深度
unsigned int Depth(Mul_Lists *LS);
//获取表头数据
LS_Data *GetHead(Mul_Lists *LS);
//获取表尾数据
LS_Data *GetTail(Mul_Lists *LS);
//插入元素(第一个元素)
void InsertFirst(Mul_Lists *LS, const LS_Data Data);
//删除元素(第一个元素)
LS_Data DeleteFirst(Mul_Lists *LS);
//遍历广义表
void Traverse(Mul_Lists* LS);

4， 操作代码实现

4.1，构造广义表

 首先我们先定义一个用于构造结点的函数。

//返回结点
static LS_Node *GetListsNode(ElemTag Tag)
{
    LS_Node *newNode = (LS_Node *)malloc(sizeof(LS_Node));
    if (PTR_IS_NULL(newNode))
        return NULL;
    //构造原子结点
    if (Tag == ATOM)
    {
        newNode->value.data = 0;
        newNode->value.number = ' ';
        newNode->Tag = ATOM;
    }
    //构造列表结点
    else if (Tag == LIST)
    {
        newNode->Tag = LIST;
        newNode->ptr.hp = newNode->ptr.tp = NULL;
    }
    return newNode;
}

 在构造表的时候，我们采用递归建表。


//构造广义表
void InitMulLists(Mul_Lists *LS, char *Num, LS_Data Data[], int Len)
{
    int len = 0;//记录表长度
    LS_Node *curPtr = NULL;
    //如果表的编号为空就直接返回
    if (!STRING_LEN(Num))
        return;
        //给头结点赋值，只做一次（即进入递归之后不能修改头结点）
    if (!LS->len)
    {
        LS->lastNode = LS->headPtr = GetListsNode(LIST);
        curPtr = LS->lastNode;
    }
    //进入递归后会执行else中的代码
    else
    {
        curPtr = GetListsNode(LIST);
        LS->lastNode->ptr.hp = curPtr;
        LS->lastNode = curPtr;
    }
    LS->len++;
    //表长加一
    ++len;
    //删除首字符
    DeleteString(Num);
    while (STRING_LEN(Num))
    {
        //修改LS中的表长
        LS->len = len;
        if (Num[0] == '(')
        {
            //记录尾结点
            LS->lastNode = curPtr;
            //进入递归
            InitMulLists(LS, Num, Data, Len);
        }
        else if (Num[0] == ',')
        {
            curPtr = LS->lastNode;
            curPtr->ptr.tp = GetListsNode(LIST);
            curPtr = curPtr->ptr.tp;
            LS->lastNode = curPtr;
            //表长加一
            ++len;
        }
        else if (Num[0] == ')')
        {
            break;
        }
        else
        {
            //链接新节点
            curPtr->ptr.hp = GetListsNode(ATOM);
            //给节点数据赋值
            curPtr->ptr.hp->value = Data[0];
            //移除第一个数据
            DeleteArray(Data, &Len);
        }
         //删除首字符
        DeleteString(Num);
    }
}

4.2 ，遍历广义表

 在遍历时，我们需要一个辅助函数来输出结点信息。


//输出结点信息
static void ShowNodeInfo(LS_Node *Node)
{
    while (Node)
    {
        if (Node->ptr.hp->Tag == ATOM)
        {
            printf("结点编号：%c 结点数据：%d\n", Node->ptr.hp->value.number, Node->ptr.hp->value.data);
        }
        else if (Node->ptr.hp->Tag == LIST)
        {
            ShowNodeInfo(Node->ptr.hp);
        }
        Node = Node->ptr.tp;
    }
}

 遍历时也需要使用递归的方式来访问到所有的节点。

//遍历广义表
void Traverse(Mul_Lists *LS)
{
    LS_Node *head = LS->headPtr;
    if (PTR_IS_NULL(head))
        return;
    ShowNodeInfo(head);
}

4.3，销毁广义表

 在销毁广义表时，我们定义一个辅助函数来帮助我们销毁。


//销毁结点
static void FreeMulListsNode(LS_Node *Node)
{
    LS_Node *temp = NULL;
    while (Node)
    {
        if (Node->ptr.hp->Tag == ATOM)
        {
            //释放原子结点
            free(Node->ptr.hp);
        }
        else if (Node->ptr.hp->Tag == LIST)
        {
            //递归删除列表结点
            FreeMulListsNode(Node->ptr.hp);
        }
        //保存下一个结点的位置
        temp = Node->ptr.tp;
        //释放列表结点
        free(Node);
        Node = temp;
    }
}

 和构建，遍历广义表一样，在销毁时，我们也需要递归的删除。

//销毁广义表
void Destroy(Mul_Lists *LS)
{
    LS_Node *head = LS->headPtr;
    if (PTR_IS_NULL(head))
        return;
    FreeMulListsNode(head);
}

4.4，判断广义表是否为空

 该操作非常简单，直接判断头结点指针是否为空即可。

//广义表是否为空
bool Empty(Mul_Lists *LS)
{
    return PTR_IS_NULL(LS->headPtr);
}

4.5，获取表头数据

 由于在我们的表结构中存储了头结点指针，因此我们只需访问头指针数据即可。

//获取表头数据
LS_Data *GetHead(Mul_Lists *LS)
{
    return &LS->headPtr->ptr.hp->value;
}

4.6，获取表尾数据

 由于在我们的表结构中存储了尾结点指针，因此我们只需访问尾指针数据即可。

//获取表尾数据
LS_Data *GetTail(Mul_Lists *LS)
{
    return &LS->lastNode->ptr.hp->value;
}

4.7，计算广义表的长度

 广义表的长度实际就是广义表中数据元素的数量，子表算一个元素，原子算一个元素。
例如表LS=（a，（b，c），d，（e，（f）））
该表的长度就为4。其中a、（b，c）、d、（e，（f））都是一个元素。
  由于在我们构建广义表的时候就已经记录过表的长度了，所以不需要再去重新遍历表，重新计算长度。

//获取广义表的长度
unsigned int Length(Mul_Lists *LS)
{
    return LS->len;
}

4.8，计算广义表的深度

 广义表的深度定义为广义表中括弧（括号）的重数，是广义表的一种度量。如果广义表的结点为原子结点其深度就为0，如果是空表，那么其深度就为1。因此广义表的深度计算其实就是计算元素中子表的嵌套层数，取最大值，然后将其层数+1，就是广义表的深度。
  例如：广义表LS=（（），a，（b，c），d，（e，（f）））
将该表拆分：
结点（）为空表，深度为1
子表LS1=a，（b，c），d，（e，f）
结点a为原子，深度为0
子表LS2=（b，c），d，（e，（f））
结点（b，c）为列表，深度为1
子表LS3=d，（e，（f））
结点d为原子，深度为0
结点（e，（f））为列表，该表中又嵌套了列表（f），因此他的深度为2
由此可得列表（e，（f））的深度最大，所以该表的深度就为2+1=3。
  所以广义表的深度计算递归算法就有2个终结状态，空表和原子。在此我们需要一个辅助函数来帮助我们实现递归算法。

//计算广义表深度
static int ListsDepth(LS_Node *Node)
{
    //如果表为空表时，直接返回长度1；
    if (PTR_IS_NULL(Node))
    {
        return 1;
    }
    //如果表为原子时，直接返回0；
    if (Node->Tag == ATOM)
    {
        return 0;
    }
    int max = 0; //设置表的初始长度为0；
    LS_Node *temp = Node;
    while (temp)
    {
        int dep = ListsDepth(temp->ptr.hp);
        if (dep > max)
        {
            max = dep; //每次找到表中遍历到深度最大的表，并用max记录
        }
        temp = temp->ptr.tp;
    }
    //程序运行至此处，表明广义表不是空表，由于原子返回的是0，而实际长度是1，所以，此处要+1；
    return max + 1;
}

//获取广义表的深度
unsigned int Depth(Mul_Lists *LS)
{
    //判断广义表是否为空
    if (PTR_IS_NULL(LS->headPtr))
        return 0;
    return ListsDepth(LS->headPtr);
}

4.9，插入操作

 在这里小编只为大家展示如何在广义表的表头插入数据。首先我们要先分配一个列表结点和一个原子结点。
在这里插入图片描述
然后将新节点的tp指针指向头结点，将头指针headPtr指向新的节点
在这里插入图片描述
这里小编只展示插入类型为原子类型的数据元素，如果要插入数据类型为列表的元素，其原理和插入原子类型数据是一样的，在此小编就不演示了。

//插入元素(第一个元素)
void InsertFirst(Mul_Lists *LS, const LS_Data Data)
{
    //构造列表结点
    LS_Node *pList = (LS_Node *)malloc(sizeof(LS_Node));
    if (PTR_IS_NULL(pList))
        return;
    //标记结点类型
    pList->Tag = LIST;
    //链接新的结点
    pList->ptr.tp = LS->headPtr;
    //构造原子结点
    pList->ptr.hp = (LS_Node *)malloc(sizeof(LS_Node));
    if (PTR_IS_NULL(pList->ptr.hp))
        return;
    //标记结点类型
    pList->ptr.hp->Tag = ATOM;
    //更新结点数据
    pList->ptr.hp->value = Data;
    //更新头结点
    LS->headPtr = pList;
    //表长加一
    LS->len++;
}

4.10，删除操作

 删除操作则与插入操作相反，我们要先来一个临时指针记录一下要删除的节点的位置，然后再修改头指针指向要删除节点的后一个节点。
在这里插入图片描述
最后在释放要删除节点的内存

//删除元素(第一个元素)
LS_Data DeleteFirst(Mul_Lists *LS)
{
    LS_Data d = {0, '0'};
    if (PTR_IS_NULL(LS->headPtr))
        return d;
    //如果头结点是列表结点，我们什么也不做
    if (LS->headPtr->ptr.hp->Tag == LIST)
        return d;
    LS_Node *delNode = LS->headPtr;
    //拷贝一下删除节点的数据
    d = delNode->ptr.hp->value;
    //后续节点变为头结点
    LS->headPtr = delNode->ptr.tp;
    //释放节点
    free(delNode->ptr.hp);
    free(delNode);
    //表长减一
    LS->len--;
    return d;
}

在这里小编也只展示在表头删除元素类型为原子类型的节点。

5，代码测试

#include "MultipleLists.h"
#include <stdio.h>

int main(void)
{
    Mul_Lists LS=GetMulLists();
   
    LS_Data data[6];
    for (size_t i = 0; i < 6; i++)
    {
        data[i].data = i + 100;
        data[i].number = 'a' + i;
    }
    char s[CHAR_LEN] = "(a,b,(c,d),e,f)";
    int i = 6;
    InitMulLists(&LS, s, data, i);
    Traverse(&LS);
    printf("尾结点：%c\n", GetTail(&LS)->number);
    printf("头结点：%c\n", GetHead(&LS)->number);
    printf("长度：%d\n", Length(&LS));
    printf("深度：%d\n", Depth(&LS));
    LS_Data d = {100, 'p'};
    InsertFirst(&LS, d);
    printf("插入元素后：\n");
    Traverse(&LS);
    printf("删除元素后：\n");
    d= DeleteFirst(&LS);
    printf("删除的结点编号： %c 数值：%d\n",d.number,d.data);
    Traverse(&LS);
    printf("销毁广义表后：\n");
    Destroy(&LS);
     Traverse(&LS);
    getchar();
    return 0;
}

在这里插入图片描述

6，完整代码

.h文件

#ifndef _MULTIPLELISTS_H_
#define _MULTIPLELISTS_H_
#include <stdbool.h>


#define CHAR_LEN 20


//节点类型枚举
typedef enum
{
    ATOM, //原子类型
    LIST  //列表类型
} ElemTag;

struct LS_Data
{
    int data;    //存储数据
    char number; //存储编号
};
typedef struct LS_Data LS_Data;

struct LS_Node
{
    ElemTag Tag; //结点类型标识
    union
    {
        LS_Data value;
        struct
        {
            struct LS_Node *hp; //表头指针
            struct LS_Node *tp; //表尾指针
        } ptr;
    };
};

typedef struct LS_Node LS_Node;

struct Mul_Lists
{
    LS_Node *headPtr;//头结点
    unsigned int len;//表的长度
    LS_Node *lastNode;//末尾节点
};

typedef struct Mul_Lists Mul_Lists;

//返回一个空的广义表
Mul_Lists GetMulLists(void);
//构造广义表
void InitMulLists(Mul_Lists *LS, char *Num, LS_Data Data[], int Len);
//广义表是否为空
bool Empty(Mul_Lists *LS);
//销毁广义表
void Destroy(Mul_Lists *LS);
//获取广义表的长度
unsigned int Length(Mul_Lists *LS);
//获取广义表的深度
unsigned int Depth(Mul_Lists *LS);
//获取表头数据
LS_Data *GetHead(Mul_Lists *LS);
//获取表尾数据
LS_Data *GetTail(Mul_Lists *LS);
//插入元素(第一个元素)
void InsertFirst(Mul_Lists *LS, const LS_Data Data);
//删除元素(第一个元素)
LS_Data DeleteFirst(Mul_Lists *LS);
//遍历广义表
void Traverse(Mul_Lists* LS);

#endif

.cpp文件

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

#define PTR_IS_NULL(PTR) (PTR == NULL ? true : false)
#define STRING_LEN(STR) (strlen(STR))

//返回结点
static LS_Node *GetListsNode(ElemTag Tag);
//从数据数组中删除一个元素(伪删除)
static LS_Data *DeleteArray(LS_Data Data[], int *Len);
//从字符数组中删除首字符
static char *DeleteString(char **Str);
//输出结点信息
static void ShowNodeInfo(LS_Node *Node);
//销毁结点
static void FreeMulListsNode(LS_Node *Node);
//计算广义表深度
static int ListsDepth(LS_Node *Node);

//返回一个空的广义表
Mul_Lists GetMulLists(void)
{
    Mul_Lists LS;
    LS.headPtr = LS.lastNode = NULL;
    LS.len = 0;
    return LS;
}

//构造广义表
void InitMulLists(Mul_Lists *LS, char *Num, LS_Data Data[], int Len)
{
    int len = 0;//记录表长度
    LS_Node *curPtr = NULL;
    //如果表的编号为空就直接返回
    if (!STRING_LEN(Num))
        return;
        //给头结点赋值，只做一次（即进入递归之后不能修改头结点）
    if (!LS->len)
    {
        LS->lastNode = LS->headPtr = GetListsNode(LIST);
        curPtr = LS->lastNode;
    }
    //进入递归后会执行else中的代码
    else
    {
        curPtr = GetListsNode(LIST);
        LS->lastNode->ptr.hp = curPtr;
        LS->lastNode = curPtr;
    }
    LS->len++;
    //表长加一
    ++len;
    //删除首字符
    DeleteString(Num);
    while (STRING_LEN(Num))
    {
        //修改LS中的表长
        LS->len = len;
        if (Num[0] == '(')
        {
            //记录尾结点
            LS->lastNode = curPtr;
            //进入递归
            InitMulLists(LS, Num, Data, Len);
        }
        else if (Num[0] == ',')
        {
            curPtr = LS->lastNode;
            curPtr->ptr.tp = GetListsNode(LIST);
            curPtr = curPtr->ptr.tp;
            LS->lastNode = curPtr;
            //表长加一
            ++len;
        }
        else if (Num[0] == ')')
        {
            break;
        }
        else
        {
            //链接新节点
            curPtr->ptr.hp = GetListsNode(ATOM);
            //给节点数据赋值
            curPtr->ptr.hp->value = Data[0];
            //移除第一个数据
            DeleteArray(Data, &Len);
        }
         //删除首字符
        DeleteString(Num);
    }
}

//广义表是否为空
bool Empty(Mul_Lists *LS)
{
    return PTR_IS_NULL(LS->headPtr);
}
//销毁广义表
void Destroy(Mul_Lists *LS)
{
    LS_Node *head = LS->headPtr;
    if (PTR_IS_NULL(head))
        return;
    FreeMulListsNode(head);
}
//获取广义表的长度
unsigned int Length(Mul_Lists *LS)
{
    return LS->len;
}
//获取广义表的深度
unsigned int Depth(Mul_Lists *LS)
{
    //判断广义表是否为空
    if (PTR_IS_NULL(LS->headPtr))
        return 0;
    return ListsDepth(LS->headPtr);
}
//获取表头数据
LS_Data *GetHead(Mul_Lists *LS)
{
    return &LS->headPtr->ptr.hp->value;
}
//获取表尾数据
LS_Data *GetTail(Mul_Lists *LS)
{
    return &LS->lastNode->ptr.hp->value;
}
//插入元素(第一个元素)
void InsertFirst(Mul_Lists *LS, const LS_Data Data)
{
    //构造列表结点
    LS_Node *pList = (LS_Node *)malloc(sizeof(LS_Node));
    if (PTR_IS_NULL(pList))
        return;
    //标记结点类型
    pList->Tag = LIST;
    //链接新的结点
    pList->ptr.tp = LS->headPtr;
    //构造原子结点
    pList->ptr.hp = (LS_Node *)malloc(sizeof(LS_Node));
    if (PTR_IS_NULL(pList->ptr.hp))
        return;
    //标记结点类型
    pList->ptr.hp->Tag = ATOM;
    //更新结点数据
    pList->ptr.hp->value = Data;
    //更新头结点
    LS->headPtr = pList;
    //表长加一
    LS->len++;
}
//删除元素(第一个元素)
LS_Data DeleteFirst(Mul_Lists *LS)
{
    LS_Data d = {0, '0'};
    if (PTR_IS_NULL(LS->headPtr))
        return d;
    //如果头结点是列表结点，我们什么也不做
    if (LS->headPtr->ptr.hp->Tag == LIST)
        return d;
    LS_Node *delNode = LS->headPtr;
    //拷贝一下删除节点的数据
    d = delNode->ptr.hp->value;
    //后续节点变为头结点
    LS->headPtr = delNode->ptr.tp;
    //释放节点
    free(delNode->ptr.hp);
    free(delNode);
    //表长减一
    LS->len--;
    return d;
}

//输出结点信息
static void ShowNodeInfo(LS_Node *Node)
{
    while (Node)
    {
        if (Node->ptr.hp->Tag == ATOM)
        {
            printf("结点编号：%c 结点数据：%d\n", Node->ptr.hp->value.number, Node->ptr.hp->value.data);
        }
        else if (Node->ptr.hp->Tag == LIST)
        {
            ShowNodeInfo(Node->ptr.hp);
        }
        Node = Node->ptr.tp;
    }
}

//遍历广义表
void Traverse(Mul_Lists *LS)
{
    LS_Node *head = LS->headPtr;
    if (PTR_IS_NULL(head))
        return;
    ShowNodeInfo(head);
}

//返回结点
static LS_Node *GetListsNode(ElemTag Tag)
{
    LS_Node *newNode = (LS_Node *)malloc(sizeof(LS_Node));
    if (PTR_IS_NULL(newNode))
        return NULL;
    //构造原子结点
    if (Tag == ATOM)
    {
        newNode->value.data = 0;
        newNode->value.number = ' ';
        newNode->Tag = ATOM;
    }
    //构造列表结点
    else if (Tag == LIST)
    {
        newNode->Tag = LIST;
        newNode->ptr.hp = newNode->ptr.tp = NULL;
    }
    return newNode;
}

//从数组中删除一个元素
static LS_Data *DeleteArray(LS_Data Data[], int *Len)
{
    for (size_t i = 0; i < (*Len) - 1; i++)
    {
        (Data[i]) = (Data[i + 1]);
    }
    --(*Len);
    return Data;
}

//从字符数组中删除首字符
static char *DeleteString(char **Str)
{
    char s[CHAR_LEN] = "";
    strcpy(s, (char *)(&*Str) + 1);
    strcpy((char *)(&*Str), s);
    return NULL;
}

//销毁结点
static void FreeMulListsNode(LS_Node *Node)
{
    LS_Node *temp = NULL;
    while (Node)
    {
        if (Node->ptr.hp->Tag == ATOM)
        {
            //释放原子结点
            free(Node->ptr.hp);
        }
        else if (Node->ptr.hp->Tag == LIST)
        {
            //递归删除列表结点
            FreeMulListsNode(Node->ptr.hp);
        }
        //保存下一个结点的位置
        temp = Node->ptr.tp;
        //释放列表结点
        free(Node);
        Node = temp;
    }
}
//计算广义表深度
static int ListsDepth(LS_Node *Node)
{
    //如果表为空表时，直接返回长度1；
    if (PTR_IS_NULL(Node))
    {
        return 1;
    }
    //如果表为原子时，直接返回0；
    if (Node->Tag == ATOM)
    {
        return 0;
    }
    int max = 0; //设置表的初始长度为0；
    LS_Node *temp = Node;
    while (temp)
    {
        int dep = ListsDepth(temp->ptr.hp);
        if (dep > max)
        {
            max = dep; //每次找到表中遍历到深度最大的表，并用max记录
        }
        temp = temp->ptr.tp;
    }
    //程序运行至此处，表明广义表不是空表，由于原子返回的是0，而实际长度是1，所以，此处要+1；
    return max + 1;
}

main文件

#include "MultipleLists.h"
#include <stdio.h>

int main(void)
{
    Mul_Lists LS=GetMulLists();
   
    LS_Data data[6];
    for (size_t i = 0; i < 6; i++)
    {
        data[i].data = i + 100;
        data[i].number = 'a' + i;
    }
    char s[CHAR_LEN] = "(a,b,(c,d),e,f)";
    int i = 6;
    InitMulLists(&LS, s, data, i);
    Traverse(&LS);
    printf("尾结点：%c\n", GetTail(&LS)->number);
    printf("头结点：%c\n", GetHead(&LS)->number);
    printf("长度：%d\n", Length(&LS));
    printf("深度：%d\n", Depth(&LS));
    LS_Data d = {100, 'p'};
    InsertFirst(&LS, d);
    printf("插入元素后：\n");
    Traverse(&LS);
    printf("删除元素后：\n");
    d= DeleteFirst(&LS);
    printf("删除的结点编号： %c 数值：%d\n",d.number,d.data);
    Traverse(&LS);
    printf("销毁广义表后：\n");
    Destroy(&LS);
     Traverse(&LS);
    getchar();
    return 0;
}
.Hardess
关注
  • 10
    点赞
  • 踩
  • 106
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构广义表c语言实现（每行都有注释）
12-13
//广义表结构 typedef enum{atom,list} NodeTag; typedef struct GLNode{ NodeTag tag;//用以区分原子节点和表节点 union{//c语言共用体 DataType data;//用以存放原子节点的值 struct GLNode *slink;//指向自表...
9. 广义表 - 广义表概念，存储结构，深度/长度，复制算法
园长QwQ
03-23 4万+
文章目录9. 广义表9.1 广义表的基础概念9.2 广义表的存储结构9.3 广义表的深度和长度9.3.1 广义表的长度9.3.2 广义表的深度9.4 广义表的复制 9. 广义表 9.1 广义表的基础概念 1 ）什么是广义表 广义表，又称列表，也是一种线性存储结构，既可以存储不可再分的元素，也可以存储广义表，记作：LS = (a1,a2,…,an)，其中，LS 代表广义表的名称，an 表示广义表存储的数据，广义表中每个 ai 既可以代表单个元素，也可以代表另一个广义表。 2 ）广义表的原子和子表 广义表
数据结构与算法丨广义表
兔子王
10-19 5273
数据结构与算法之列表。
数据结构 第四章 广义表
weixin_62917800的博客
05-08 5968
4.5 广义表 4.5.1广义表的定义 广义表是线性表的推广，也称列表。广泛地用于人工智能等领域的表处理语言LISP语言，把广义表作为基本的数据结构，就连程序也表示为一系列的广义表。 广义表一般记作，其中可以是单个元素，也可以是一个广义表。广义表的定义是一个递归的过程，相当于单个元素可以是广义表，这个广义表内的元素又可以有广义表...... 下面我们列举一些广义表的例子。 1）A=( )，A是一个空表，其长度为0。 2）B=(e)，B只有一个元素， ...
数据结构学习笔记——广义表
最新发布
小宇y的博客
12-04 3967
广义表是线性表的进一步推广，是由n（n≥0）个数据元素组成的有序序列。线性表中的数据元素只能是单个元素（原子），它是不可分割的，而广义表中的数据元素既可以是原子，也可以是一个广义表（包括空表和非空表），广义表通过圆括号“()”括起来，通过逗号“”隔开表中的各个数据元素。一个n维数组可以看成元素是n-1维数组的广义表，广义表的元素都是n-1维数组。另外，若广义表中的所有元素都是原子时，此时的广义表就是一个线性表。广义表H=((a,b),(c,(d,e)))，括号层数为3，所以广义表的深度为3，最高层为(c,(
数据结构-广义表
有朋自远方来，不亦乐乎。
08-15 5129
广义表又称列表，也是一种线性存储结构，通数组类似，广义表中即可存储不可再分的元素也能存储可在分元素。例如：数组中可以存储‘a’、3这样的字符或数字，也能存储数组，比如二维数组、三维数组，数组都是可在分成子元素的。广义表也是如此，但与数组不同的是，在广义表中存储的数据是既可以再分也可以不再分的，形如：{1,{1,2,3}}。如果创建一个二维数组来存储{1,{1,2,3}}。在存储上确实可以实现，但无疑会造成存储空间的浪费。广义表记作：其中，LS 代表广义表的名称，an 表示广义表存储的数据。...
数据结构-PPT课件_C语言_栈广义表树图_数据结构PPT_
10-02
在这个"数据结构-PPT课件_C语言_栈广义表树图_数据结构PPT"中，我们将会探讨一系列重要的数据结构和算法，这些对于理解和解决复杂计算问题至关重要。 首先，线性表是最基本的数据结构之一，它由有序元素序列构成。...
数据结构——数组及广义表.cpp
03-08
数据结构——数组及广义表.cpp
广义表数据结构ADT实现代码
12-02
总之，广义表ADT的实现涉及了数据结构、算法和C语言编程基础等多个方面的知识。通过这个项目，不仅可以学习到广义表的基本操作，还能了解到如何设计和实现一个完整的ADT，这对于深入理解和应用数据结构有极大的帮助...
数据结构PPT详解（C语言版）
08-20
数据结构（C语言版）在选材与编排上，贴近当前普通高等院校“数据结构”课程的现状和发展趋势，符合新研究生考试大纲，内容难度适度，突出实用性和应用性。全书共7章，内容包括绪论，线性表，栈和队列，串、数组和...
数据结构之广义表
weixin_64144469的博客
05-22 6805
1.广义表的定义 顾名思义，广义表是线性表的推广，也称为列表。 用大写字母表示广义表的名称,用小写字母表示原子 (l) A = ()----------A是一个空表， 其长度为零。 (2) B=(e)--------B 只有一个原子 e, 其长度为1。 (3) C= (a, (b, c, d))-------C的长度为2, 两个元素分别为原子 a 和子表(b,c, d)。 (4) D = (A, B, C)---------D的长度为3,3个元素都是广义表。显然，将子表的值代入后，则.
广义表的长度和深度
热门推荐
zhangkongzhongyun的专栏
03-24 5万+
广义表LS=(f,(),(e),(a,(b,c,d)))的长度是多少,深度是多少 例如上表、长度为4、深度为3、为什么呢 长度的求法为最大括号中的逗号数加一、LS最大括号内有 1. f 元素后边有个逗号、 2.（）元素后有个逗号、 3.（e）元素后有个逗号 4. （a，（b，c，d））后边没有逗号 ----把这个看成是一个元素 也就是三个逗号 同样被分成四组、长度就为四了
广义表
kong_xz的博客
03-08 4万+
一、广义表的定义广义表简称表，它是线性表的推广。一个广义表是n（n≥0）个元素的一个序列，若n=0时则称为空表。设ai为广义表的第i个元素,则广义表GL的一般表示与线性表相同：            GL=(a1,a2,…,ai,…,an)其中n表示广义表的长度，即广义表中所含元素的个数，n≥0。如果ai是单个数据元素，则ai是广义表GL的原子；如果ai是一个广义表，则ai是广义表GL的子表。 广...
计算机考研常考：广义表的定义以及数据结构，你都会了吗？
BoldFruit的博客
06-06 1万+
什么是广义表 广义表的定义 线性表 线性表指的是n≥0个元素a1, a2, a3…的有序数列，并且线性表的元素具有原子性，即结构上是不可分割的一个整体。 广义表(Generalized list) 而广义表则是线性表的一种扩展延伸。相对于线性表，广义表最大的特点在于其元素既可以是一个确定的类型，同时也可以是另一个有不定数量的元素组成的表（广义表）。 不难看出从广义表的定义是递归的。广义表是线性表的递归数据结构。 广义表的基本概念 广义表的表示 我们通常可以用 GL = (a1, a2, a3… an)来
广义表的深度和长度
fu_jian_ping的博客
04-13 1万+
广义表记做： LS = （a1, a2, a3, a4......an）。 其中，LS是广义表的表名，n是广义表的长度。 广义表中嵌套的括号的层数为其深度。 案例： 广义表 L = （（a, b, c）, e） 分析： 根据广义表的定义可知，a1=(a, b, c), a2=3 所以其长度为2。 广义表的括号嵌套层数为2，所以其深度为2。 ...
数据结构之广义表的相关知识点
IT之旅 的博客
06-04 1万+
一，广义表的基本概念: 广义表(Lists，又称列表)是一种非线性的数据结构，是线性表的一种推广。即广义表中放松对表元素的原子限制，容许它们具有其自身结构（即可以有子表）。它被广泛的应用于人工智能等领域的表处理语言LISP语言中。在LISP语言中，广义表是一种最基本的数据结构，就连LISP 语言的程序也表示为一系列的广义表。 二，广义表的基本表示： 1， 概念角度分析：...
广义表(Generalized List)
Catherine的笔记
09-27 6863
广义表(Generalized List) 1. 广义表的概念 1.1 广义表的定义 广义表(Generalized List，又称列表，或表)是一种非线性的数据结构，是线性表的一种推广。 广义表中放松对表元素的原子限制，容许它们具有其自身结构。即广义表的定义是递归的，因为在表的描述中又用到了表，允许表中有表，这种递归的定义能够很简洁地描述庞大而复杂的结构。 一个广义表LS定义为n(n≥0)个元素a0,a1,a
数据结构--广义表
qq_55552561的博客
10-23 1485
任何一个非空的广义表都可以将其分解成表头和表尾两部分，反之，一对确定的表头和表尾可以唯一地确定一个广义表。A=（a,（b，c））：表长度为2的广义表，第一个元素是单个数据a，第二个元素是一个子表（b，c）。C=（a，C）：长度为2递归定义的广义表，C相当于无穷表C=（a,（a,（a,（…B=（A，A，D）：长度为3的广义表，前两个元素为表A，第三个元素为空表D。① 广义表的元素可以是子表，而子表还可以是子表，因此广义表是一个多层的结构。广义表的深度定义为广义表中括弧的重数，是广义表的一种量度。
数据结构C语言广义表
08-24
广义表是一种扩展了线性表的数据结构，能够存储多层次的数据。在C语言中，可以通过链表来实现广义表。 首先，我们需要定义广义表的节点结构。一个广义表节点包含一个元素值和两个指针，分别指向下一个元素节点和子广义表的头节点。可以使用以下结构体表示： ```c typedef struct GNode { int tag; // 标志位，用于区分元素节点和子广义表节点，0表示元素节点，1表示子广义表节点 union { int data; // 元素节点的值 struct GNode* subList; // 子广义表的头节点指针 }; struct GNode* next; // 指向下一个节点的指针 } GNode; ``` 通过上述节点结构，可以构建出一个广义表的链表。在链表中，每个节点可以是元素节点或子广义表节点。当节点的tag为0时，表示该节点是一个元素节点，此时可以通过data字段访问该节点的值。当节点的tag为1时，表示该节点是一个子广义表节点，此时可以通过subList字段访问该子广义表的头节点。 可以通过以下代码示例来创建一个包含元素和子广义表的广义表： ```c GNode* createGNode(int tag, int data, GNode* subList) { GNode* node = (GNode*)malloc(sizeof(GNode)); node->tag = tag; if (tag == 0) { node->data = data; } else if (tag == 1) { node->subList = subList; } node->next = NULL; return node; } GNode* createGeneralList() { GNode* list = createGNode(1, 0, NULL); // 创建一个空的子广义表 list->next = createGNode(0, 1, NULL); // 创建一个元素节点，值为1 list->next->next = createGNode(0, 2, NULL); // 创建一个元素节点，值为2 list->subList = createGNode(1, 0, NULL); // 创建一个空的子广义表作为头节点的子表 list->subList->subList = createGNode(0, 3, NULL); // 在子广义表中创建一个元素节点，值为3 return list; } ``` 上述代码中，`createGeneralList`函数创建了一个广义表，包含了元素节点1、2和子广义表。 这只是广义表在C语言中的一种实现方式，你可以根据实际需求来选择适合的数据结构和实现方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值