数据结构算法C语言实现（十九）--- 5.5&5.6&5.7广义表

　　一.简述

　　传说Lisp的基本数据结构就是广义表，广义表也是具有典型递归属性的数据结构，此外，由于建表要处理字符串，用C语言处理起来也是一脸懵逼.....最后自己还想写一个将广义表还原成字符串的函数，一是使其可视化，而是验证算法5.6。花了不少功夫才写出来（强烈建议自己动手写一写），最后是借助树形结构的角度才找到一个不错的解决办法。按照《数据结构编程实验》的分类，数据结构无非线性结构、树状结构、图结构，可以说树是特殊的图（图的最小生成树），线性表示特殊的树。。。。。扯远了！

　　二.头文件

　　补充版字符串处理头文件

//4_2_part1.h
/**
author:zhaoyu
*/
//2016-6-10
//----串的定长顺序存储表示----
#ifndef _4_2_PART1_H_
#define _4_2_PART1_H_
#include "head.h"
#define MAXSTRLEN 255//用户可以在255以内定义最大串长
//这语法还不是很熟悉
typedef unsigned char SString[MAXSTRLEN+1];//0 号单元存放串的长度
int StrLength(SString T)
{
    for (int i = 1; i <= MAXSTRLEN; ++i)
    {
        if ('' == T[i])
        {
            return i-1;
        }
    }
    return MAXSTRLEN;
}

/**
algorithm 4.2
*/
Status Concat(SString &T, SString S1, SString S2)
{
    //用 T 返回由 S1 和 S2 连接而成的新串。
    //若未截断，则返回 TRUE，否则返回 FALSE
    Status uncut;
    if (S1[0] + S2[0] < MAXSTRLEN)
    {//未截断
        int i = 1;
        for (i = 1; i <= S1[0]; ++i)
        {
            T[i] = S1[i];
        }
        for (i = 1; i <= S2[0]; ++i)
        {
            T[S1[0]+i] = S2[i];
        }
        T[0] = S1[0] + S2[0];
        uncut = TRUE;
    }
    else if (S1[0] < MAXSTRLEN)
    {
        int i = 1;
        for (i = 1; i <= S1[0]; i++)
        {
            T[i] = S1[i];
        }
        for (i = S1[0]+1; i <= MAXSTRLEN; i++)
        {
            T[i] = S2[i-S1[0]];
        }
        T[0] = MAXSTRLEN;
        uncut = FALSE;
    }
    else
    {
        for (int i = 1; i <= MAXSTRLEN; i++)
        {
            T[i] = S1[i];
        }
        T[0] = S1[0] = MAXSTRLEN;
        uncut = FALSE;
    }
    return uncut;
}
/**
algorithm 4.3
*/
Status SubString(SString &Sub, SString S, int pos, int len)
{
    //用 Sub 返回串 S 的第 pos 个字符起长度为 len 的字串
    //其中， 1<= pos <<= SreLength(S) 且 0 <= len <= StrLength(S)-pos+1
    if (pos < 1 || pos > S[0] || len < 0 || len > S[0]-pos+1)
    {
        return ERROR;
    }
    for (int i = 1; i <= len; i++)
    {
        Sub[i] = S[i+pos-1];
    }
    Sub[len+1] = '';
    Sub[0] = len;
    return OK;
}
/**
add for chapter 5 / page 116.117
*/
Status StrCompare(SString S, SString T)
{
    for (int i = 1; i <= S[0] && i <=T[0]; i++)
    {
        if (S[i]-T[i] > 0){
            return 1;
        }
        if (S[i]-T[i] < 0)
        {
            return -1;
        }
    }
    if (S[0] == T[0])
    {
        return 0;
    }
    return S[0]>T[0]?1:-1;
}
Status StrEmpty(SString S)
{
    if (0 == StrLength(S))
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
Status StrCopy(SString &T, SString S)
{//健壮性并不够
    for (int i = 0; i <= S[0]+1; i++)
    {
        T[i] = S[i];
    }
    return OK;
}
Status ClearString(SString S)
{
    S[0] = 0;
    S[1] = '';
    return OK;
}
void PrintSString(SString T)
{
    //if(T[])
    for (int i = 1; i <= T[0]; ++i)
    {
        printf("%c", *(T+i));
    }
    printf("
");
}
#endif

//5_5.h
/**
author:zhaoyu
date；2016-6-16
*/
//----广义表的头尾链表存储表示----
#include "4_2_part1.h"
#define AtomType char
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;//广义表类型
/**
algorithm 5.5
*/
int GListDepth(GList L)
{//采用头尾链表存储结构，求广义表 L 深度
    if (!L)
    {
        return 1;//空表深度为 1
    }
    if (L->tag == ATOM)
    {
        return 0;//原子深度为 0
    }
    int MAX = 0;
    for (GList pp = L; pp; pp = pp->ptr.tp)
    {
        int t = GListDepth(pp->ptr.hp);//求以 ptr.hp 为头指针的子表深度
        MAX = MAX>t?MAX:t;
    }
    return MAX+1;
}
/**
algorithm 5.8
*/
Status sever(SString &str, SString &hstr)
{//将非空串 str 分割成两部分：hsub为第一个','之前的字串，str 为之后的子串
    int n = StrLength(str);
    int i = 0, k = 0;//k 记尚未配对的左括号的个数
    char ch;
    SString CH;
    do{
        ++i;
        SubString(CH, str, i, 1);
        ch = CH[1];
        if ('(' == ch)
        {
            ++k;
        }
        else if (')' == ch){
            --k;
        }
    }while (i < n && (',' != ch || 0 != k));
    if (i < n)
    {
        SubString(hstr, str, 1, i-1);
        SubString(str, str, i+1, n-i);
    }
    else
    {
        StrCopy(hstr, str);
        ClearString(str);
    }
}

/**
algorithm 5.7
*/
Status CreateGList(GList &L, SString S)
{//采用头尾链表存储结构，由广义表的书写形式串 S 创建广义表 L,设emp="()"
    GList q = NULL, p = NULL;
    SString emp = { 2, '(', ')', ''};
    SString sub, hsub;
    if ( 0 == StrCompare(S, emp))
    {//创建空表
        L = NULL;
    }
    else
    {
        if (!(L = (GList)malloc(sizeof(GLNode))))
        {
            exit(OVERFLOW);//建表结点
        }
        if (1 == StrLength(S))
        {//创建单原子广义表
            L->tag = ATOM;
            L->atom = S[1];
        }
        else
        {
            L->tag = LIST;
            p = L;
            SubString(sub, S, 2, StrLength(S)-2);
            do{//重复建 n 个子表
                sever(sub, hsub);//从 sub 中分离出表头串 hsub
                CreateGList(p->ptr.hp, hsub);
                q = p;
                if (!StrEmpty(sub))
                {//表尾不空
                    if (!(p = (GList)malloc(sizeof(GLNode))))
                    {
                        exit(OVERFLOW);
                    }
                    p->tag = LIST;
                    q->ptr.tp = p;
                }//if
            }while (!StrEmpty(sub));
            q->ptr.tp = NULL;
        }//else
    }
}
/**
algorithm 5.6
*/
Status CopyGList(GList &T, GList L)
{//采用头尾链表存储结构，由广义表 L 复制得到广义表 T
    if (!L)
    {
        T = NULL;
    }
    else
    {
        if (!(T = (GList)malloc(sizeof(GLNode))))
        {
            exit(OVERFLOW);
        }
        T->tag = L->tag;
        if (ATOM == L->tag)
        {
            T->atom = L->atom;
        }
        else
        {
            CopyGList(T->ptr.hp, L->ptr.hp);
            CopyGList(T->ptr.tp, L->ptr.tp);
        }
    }
    return OK;
}

/**
my code
*/
int cnt = 0;
void PrintGList(GList L)
{
    if (NULL == L)
    {
        printf("()");
    }
    else
    {
        if (ATOM == L->tag)
        {
            printf("%c", L->atom);
        }
        else
        {
            if (NULL == L->ptr.hp)
            {
                printf("(");
            }
            if (NULL != L->ptr.hp && LIST == L->ptr.hp->tag)
            {
                printf("(");
            }
            PrintGList(L->ptr.hp);        
            if (NULL != L->ptr.tp && LIST == L->ptr.tp->tag)
            {
                printf(",");
            }
            if (NULL == L->ptr.tp)
            {
                printf(")");
            }
            else
            {
                PrintGList(L->ptr.tp);
            }
            
            
        }
    }
}

　　三.CPP文件

#include "5_5.h"
int main(int argc, char const *argv[])
{
//    freopen("out.txt", "w", stdout);
    //test function sever

    SString s, t;
    scanf("%s", s+1);
    s[0] = StrLength(s);
    sever(s, t);
    printf("t:%s
", t+1);
    printf("s:%s
", s+1);

    GList L = NULL, T = NULL;
    SString S;
    scanf("%s", S+1);
    S[0] = StrLength(S);
    printf("len: %d
", S[0]);
    CreateGList(L, S);
    printf("
L--Depth	%d
", GListDepth(L));
    CopyGList(T, L);
    printf("
T--Depth	%d
", GListDepth(T));
    printf("T:	");
    PrintGList(T);
    printf("
");
    return 0;
}

　　四.测试

　　

　　测试用例是书上的一个例子，其结构图及对应二叉树如下