对广义表 E=((a.((b),c)),e，E)实施由取表头 GetHead 和取表尾 GetTail 组成的操 作序列（ ）得到的结果是c。的具体解题步骤

首先，我们需要理解广义表的表示方法：

- 广义表为空表，用()表示；
- 广义表非空，可以是单原子，也可以是由若干个子表组成的序列（用逗号分隔），每个子表也可以是单原子或由若干个子表组成的序列。

现在，我们来分析广义表 E=((a.((b),c)),e，E)：

- E 是一个由三个元素组成的序列，第一个元素是 ((a.((b),c))，它是一个由两个元素组成的序列；
- 第一个元素中，第一个元素是 a，第二个元素是 ((b),c)；
- 第二个元素是 e；
- 第三个元素是 E，即它本身。

接下来，我们执行 GetHead 和 GetTail 操作：

- GetHead(E) 得到 ((a.((b),c))；
- GetTail(E) 得到 (e, E)；
- GetHead(GetTail(GetHead(E))) 得到 c。

因此，由取表头 GetHead 和取表尾 GetTail 组成的操作序列得到的结果是 c。

相关问题

广义表取表头表尾_广义表的深度和长度（C语言）详解

广义表是一种数据结构，它可以看做是一个链表的集合，其中每个节点可以是一个单独的元素或者是一个子表。广义表的深度指的是广义表中嵌套的子表的最大层数，而广义表的长度指的是广义表中元素的总个数。

取广义表的表头和表尾可以使用如下的代码：

typedef struct GLNode{
    int tag; // 标志域，0表示单元素，1表示子表
    union{
        char data;
        struct GLNode *sublist;
    }val;
    struct GLNode *next;
}GLNode, *GList;

// 取广义表的表头
int getHead(GList L, char *head){
    if(L == NULL || L->tag == 1) return 0; // 空表或者表头为子表，返回0
    *head = L->val.data; // 取出表头元素
    return 1;
}

// 取广义表的表尾
int getTail(GList L, GList *tail){
    if(L == NULL) return 0; // 空表，返回0
    *tail = L->next; // 取出表尾指针
    return 1;
}

其中，广义表使用链表的形式来存储，每个节点中的tag标志域表示节点的类型，0表示单元素，1表示子表。如果节点是单元素，则val域存储该元素的值；如果节点是子表，则val域存储该子表的头指针。

使用上述代码可以方便地取出广义表的表头和表尾，但是需要注意的是，由于广义表中可能嵌套子表，因此取表尾时需要返回一个指向子表的头指针。

帮我用C语言完成以下编程（49.广义表的应用 本设计要求实现的广义表的建立、查找、输出、取表头和取表尾以及求深度。 本设计用一个主控菜单程序控制，共分为6个子系统。 （1）.建立广义表（2）输出广义表（3）结点的查找（4）求广义表表头（5）求广义表表尾（6）求广义表的深度）

以下是一个简单的 C 语言程序，实现了广义表的建立、查找、输出、取表头和取表尾以及求深度功能，通过一个主控菜单程序控制。你可以根据需要进行修改和完善。

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

#define MAXSIZE 100  // 定义广义表中最大元素个数

typedef struct gnode {
    int tag;  // 结点类型标记，0 表示原子结点，1 表示子表结点
    union {
        char data;  // 原子结点数据
        struct gnode *sublist;  // 子表结点指针
    } value;
    struct gnode *next;  // 指向下一个结点的指针
} GLNode, *GList;

// 函数声明
GList createGList();
void printGList(GList L);
int searchGList(GList L, char ch);
GList getHead(GList L);
GList getTail(GList L);
int getDepth(GList L);
void clear(GList L);

// 主函数
int main() {
    int choice;
    GList L = NULL;
    do {
        printf("\n\n");
        printf("============= 广义表的应用 =============\n");
        printf("1. 建立广义表\n");
        printf("2. 输出广义表\n");
        printf("3. 结点的查找\n");
        printf("4. 求广义表表头\n");
        printf("5. 求广义表表尾\n");
        printf("6. 求广义表的深度\n");
        printf("0. 退出程序\n");
        printf("请输入您的选择：");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                L = createGList();
                printf("广义表建立成功！\n");
                break;
            case 2:
                if (L) {
                    printf("广义表内容如下：\n");
                    printGList(L);
                } else {
                    printf("广义表为空！\n");
                }
                break;
            case 3:
                if (L) {
                    char ch;
                    printf("请输入要查找的元素：");
                    scanf(" %c", &ch);
                    int pos = searchGList(L, ch);
                    if (pos >= 0) {
                        printf("元素 %c 在广义表中的位置是 %d\n", ch, pos);
                    } else {
                        printf("元素 %c 不在广义表中！\n", ch);
                    }
                } else {
                    printf("广义表为空！\n");
                }
                break;
            case 4:
                if (L) {
                    GList head = getHead(L);
                    if (head) {
                        printf("广义表的表头是：");
                        if (head->tag == 0) {
                            printf("%c\n", head->value.data);
                        } else {
                            printf("(\n");
                        }
                    } else {
                        printf("广义表为空！\n");
                    }
                } else {
                    printf("广义表为空！\n");
                }
                break;
            case 5:
                if (L) {
                    GList tail = getTail(L);
                    if (tail) {
                        printf("广义表的表尾是：");
                        if (tail->tag == 0) {
                            printf("%c\n", tail->value.data);
                        } else {
                            printf(")\n");
                        }
                    } else {
                        printf("广义表为空！\n");
                    }
                } else {
                    printf("广义表为空！\n");
                }
                break;
            case 6:
                if (L) {
                    int depth = getDepth(L);
                    printf("广义表的深度是：%d\n", depth);
                } else {
                    printf("广义表为空！\n");
                }
                break;
            case 0:
                clear(L);
                printf("程序已退出！\n");
                break;
            default:
                printf("输入有误，请重新输入！\n");
                break;
        }
    } while (choice != 0);
    return 0;
}

// 创建广义表
GList createGList() {
    char str[MAXSIZE];
    printf("请输入广义表的字符串表示：");
    scanf("%s", str);

    int len = strlen(str);
    int i = 0;
    GList L = NULL, p = NULL;
    while (i < len) {
        char ch = str[i++];
        if (ch == '(') {
            GLNode *node = (GLNode *)malloc(sizeof(GLNode));
            node->tag = 1;
            node->value.sublist = createGList();
            node->next = NULL;
            if (!L) {
                L = node;
            } else {
                p->next = node;
            }
            p = node;
        } else if (ch == ')') {
            return L;
        } else if (ch == ',') {
            continue;
        } else {
            GLNode *node = (GLNode *)malloc(sizeof(GLNode));
            node->tag = 0;
            node->value.data = ch;
            node->next = NULL;
            if (!L) {
                L = node;
            } else {
                p->next = node;
            }
            p = node;
        }
    }
    return L;
}

// 输出广义表
void printGList(GList L) {
    if (!L) {
        return;
    }
    if (L->tag == 0) {
        printf("%c", L->value.data);
        if (L->next) {
            printf(",");
        }
        printGList(L->next);
    } else {
        printf("(");
        printGList(L->value.sublist);
        printf(")");
        if (L->next) {
            printf(",");
        }
        printGList(L->next);
    }
}

// 查找广义表中是否存在元素 ch，返回其位置（从 0 开始），若不存在则返回 -1
int searchGList(GList L, char ch) {
    if (!L) {
        return -1;
    }
    if (L->tag == 0) {
        if (L->value.data == ch) {
            return 0;
        } else {
            return searchGList(L->next, ch) == -1 ? -1 : (1 + searchGList(L->next, ch));
        }
    } else {
        int pos = searchGList(L->value.sublist, ch);
        if (pos >= 0) {
            return pos;
        } else {
            return searchGList(L->next, ch) == -1 ? -1 : (1 + searchGList(L->next, ch));
        }
    }
}

// 获取广义表的表头
GList getHead(GList L) {
    if (!L) {
        return NULL;
    }
    if (L->tag == 0) {
        return L;
    } else {
        return L->value.sublist;
    }
}

// 获取广义表的表尾
GList getTail(GList L) {
    if (!L) {
        return NULL;
    }
    return L->next;
}

// 获取广义表的深度
int getDepth(GList L) {
    if (!L) {
        return 0;
    }
    if (L->tag == 0) {
        return 0;
    } else {
        int maxDepth = 0;
        GList p = L->value.sublist;
        while (p) {
            int depth = getDepth(p);
            if (depth > maxDepth) {
                maxDepth = depth;
            }
            p = p->next;
        }
        return maxDepth + 1;
    }
}

// 释放广义表所占空间
void clear(GList L) {
    if (!L) {
        return;
    }
    if (L->tag == 1) {
        clear(L->value.sublist);
    }
    GList p = L;
    L = L->next;
    free(p);
    clear(L);
}