数据结构--广义表

// GList.cpp : Defines the entry point for the console application.
/*-----CODE FOR FUN---------------
-------CREATED BY Dream_Whui------
-------2015-2-5-------------------*/

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

#define   TRUE                    1
#define   FALSE                    0
#define   OK                    1
#define   ERROR                    0
#define   OVERFLOW                -2
#define   INFEASIBLE            -1

#define      AtomType  char

typedef enum
{
    ATOM,
    LIST
}ElemTag;//ATOM==1，表示原子；LIST==1，表示字表

typedef struct GLNode//定义广义表的结构
{
    ElemTag tag;//tag=1,表示表结点 tag=0,表示原子结点
    union
    {
        AtomType atom;//原子结点的值域
        struct
        {
            struct GLNode *hp, *tp;//表结点的指针域，hp表示表头，tp表示表尾
        }ptr;
    };
}*GList;

int CopyGList(GList &T, GList L);

int server(string &str, string &hstr)//将非空子串str分割成两部分：hstr为第一个“，”之前的子串，str为之后的子串
{
    int n;
    n = str.length();
    int i,k;
    i=k=0;
    string ch;
    do
    {
        ch = str.substr(i++,1);
        if(ch == "(")
            k++;
        else if(ch == ")")
            k--;
    }while(i<n && (ch != "," || k!=0));
    if(i<n)
    {
        hstr = str.substr(0,i-1);
        str = str.substr(i,n-i);//从字符串第i个位置开始，截取n-i个字符。（起始位置为0）
    }
    else
    {
        hstr = str;
        str.clear();//清空字符串
    }
    return OK;
}

int CreateGList(GList &L, string S)//由广义表的书写形式串S创建广义表L
{
    string emp = "()";
    string sub;
    string hsub;
    GList p,q;
    if(S==emp)
        L=NULL;//空表
    else
    {
        L = (GList)malloc(sizeof(GLNode));
        if(!L)
            return ERROR;
        if(S.length() == 1)//创建单原子广义表
        {
            L->tag = ATOM;
            L->atom = S[0];
        }
        else
        {
            L->tag = LIST;
            p = L;
            sub = S.substr(1,S.length()-2);//脱去最外层括号
            do//重复创建n个字表
            {
                server(sub,hsub);//从sub中分离出表头串hsub
                CreateGList(p->ptr.hp,hsub);
                q = p;
                if(!sub.empty())
                {
                    p = (GLNode*)malloc(sizeof(GLNode));
                    if(!p)
                        return ERROR;
                    p->tag = LIST;
                    q->ptr.tp = p;
                }
            }while(!sub.empty());
            q->ptr.tp = NULL;
        }
    }
    return OK;
}

int DestroyGList(GList &L)//销毁广义表
{
    GList q,p;
    if(L)
    {
        if(L->tag == LIST)
        {
            q = L->ptr.hp;
            p = L->ptr.tp;
            DestroyGList(q);//销毁表头
            DestroyGList(p);//销毁表尾
        }
        free(L);
        L=NULL;
    }
    return OK;
}

void Visit(AtomType e)//访问原子结点元素值
{
    cout<<e<<" ";
}

void Traverse_GL(GList L, void(*Visit)(AtomType))//遍历广义表
{
    if(L)
    {
        if(L->tag == ATOM)
            Visit(L->atom);
        else
        {
            Traverse_GL(L->ptr.hp,Visit);//遍历表头
            Traverse_GL(L->ptr.tp,Visit);//遍历表尾
        }
    }
}

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

int GListEmpty(GList L)//广义表是否空
{
    if(!L)
        return 1;
    else
        return 0;
}

GList GetHead(GList L)//获取广义表的表头
{
    GList t;
    if(!L)
        return NULL;
    else
        CopyGList(t,L->ptr.hp);
    return t;
}

GList GetTail(GList L)//获取广义表的表尾
{
    GList t;
    if(!L)
        return NULL;
    else
        CopyGList(t,L->ptr.tp);
    return t;
}

int InsertFirsst_GL(GList &L, GList e)//广义表的表头出插入元素e
{
    GList p = (GList)malloc(sizeof(GList));
    if(!p)
        return ERROR;
    p->tag = LIST;
    p->ptr.hp = e;
    p->ptr.tp = L;
    L = p;
    return OK;
}

int DeleteFirse_GL(GList &L, GList &e)//删除广义表的表头
{
    if(!L)
        return ERROR;
    GList p = L;
    e = L->ptr.hp;
    L = L->ptr.tp;
    p=NULL;
    return OK;
}

int GListDepth(GList L)//广义表的深度
{
    if(!L)
        return 1;//空表返回1
    if(L->tag == ATOM)
        return 0;//原子结点返回0
    int max;
    GList pp;
    for(max=0,pp=L; pp; pp=pp->ptr.tp)
    {
        int dep;
        dep = GListDepth(pp->ptr.hp);
        if(dep>max)
            max = dep;
    }
    return max+1;
}

int CopyGList(GList &T, GList L)//由表L复制得表L
{
    if(!L)
        T=NULL;
    else
    {
        T = (GList)malloc(sizeof(GLNode));
        if(!T)
            return ERROR;
        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);//复制表尾
        }
    }
    return OK;
}

int main(int argc, char* argv[])
{
    string A = "(A,(B,C),(),(E,(G,H)))";
    
    GList L,T;
    CreateGList(L,A);
    Traverse_GL(L,Visit);
    cout<<GListDepth(L)<<endl;
    CopyGList(T,L);
    Traverse_GL(L,Visit);
    cout<<GListDepth(L)<<endl;
    GList P;
    CreateGList(P,"(1,(1,2))");
    InsertFirsst_GL(L,P);
    Traverse_GL(L,Visit);
    GList t;
    DeleteFirse_GL(L,t);
    cout<<endl;
    Traverse_GL(L,Visit);
    DestroyGList(L);
    cout<<endl;
    Traverse_GL(L,Visit);
    return 0;
}