广义表求深度

描述

按表头、表尾的分析方法重写求广义表深度的递归算法

 

输入

输入一串以'('开始,以')'结束的字符串,并且输入的左右括号必须匹配,如:(),(())..

 

输出

分别输出按表头、表尾分析方法求广义表深度的结果，每个结果占一行。

 

输入样例

((a,b,(c,(d,e),f)),g)

 

输出样例

4

4

#include<iostream>
#include<string>
#include<cstdlib>
using namespace std;

typedef enum {ATOM,LIST} ElemTag;
typedef char AtomType;
typedef struct GLNode//GLNode是一个类型名
{
    ElemTag tag;//标志域
    union
    {
        AtomType atom;
        struct{GLNode *hp,*tp;}ptr;
        //ptr是列表，hp，tp分别指向该列表的表头和表尾
    };
    GLNode()
    {
        ptr.hp=ptr.tp=NULL;
    }
}*List;//List是指向GLNode类型变量的指针类型

class GLists
{
public:
    void GetGList(List&);//得到广义表
    void CopyGList(List&,List&);//复制广义表
    void ListTraverse(List);
    int GListDepth(List&);//求广义表深度
private:
    void CreatGList(List&,string&);//递归建立广义表
    void sever(string&,string&);//存储广义表的字符串处理
};

void GLists::GetGList(List& l)
{
    //cout<<"Please Input The Lists :"<<endl<<endl;
    string str;
    cin>>str;
    CreatGList(l,str);
}

void GLists::CreatGList(List& l,string& s)//根据给定字符串s，从l递归创建广义表
{
    List p,q;//广义表节点类型变量
    string sub,hsub;//两个字符串
    if(s=="()")//空表
        l=NULL;//l置空
    else//非空表
    {
        l=new GLNode;//建立节点
        if(s.size()==1)//原子类型
        {
            l->tag=ATOM;//标志域
            l->atom=s[0];//原子
        }//if
        else//列表类型
        {
            l->tag=LIST;//标志域
            p=l;
            sub=s.substr(1,s.size()-2);//脱去括号
            do//根据得到的列表字符串建立新的广义表
            {
                sever(sub,hsub);//得到列表中“最小单位”hsub，然后把sub置成去掉最小单位的剩余字符串
                CreatGList(p->ptr.hp,hsub);//递归建立广义表
                q=p;//记录p
                if(!sub.empty())//为下一个节点提前开辟节点空间
                {
                    p=new GLNode;
                    p->tag=LIST;//更改标志域
                    q->ptr.tp=p;//连接节点
                }
            }while(!sub.empty());
        }
    }//else
}

void GLists::CopyGList(List& t,List& l)//复制广义表l->t
{
    if(!l) t=NULL;//l是空表
    else
    {
        t=new GLNode;//开辟节点
        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 GLists::GListDepth(List& l)//求广义表深度
{
    int max=0,dep;
    List p=l;
    if(l==NULL) return 1;//空表深度为1
    if(l->tag==ATOM) return 0;//原子深度为零
    //非空列表情况
    for(;p;p=p->ptr.tp)//遍历列表
    {
        dep=GListDepth(p->ptr.hp);//递归求深度
        if(dep>max)//更新max
            max=dep;
    }
    return max+1;//返回深度
}

void GLists::sever(string &str,string &hstr)//广义表字符串处理
{//将非空字符串分割成两部分hstr为第一个','之前的部分,str为之后的部分
    int n=str.size(),i=0,k=0;
    do
    {
        if(str[i]=='(') k++;
        if(str[i]==')') k--;
        i++;
    }while(i<n&&(str[i]!=','||k!=0));
    if(i<n)
    {
        hstr=str.substr(0,i);
        str=str.substr(i+1,n-i-1);
    }
    else
    {
        hstr=str;
        str.erase(str.begin(), str.end());
    }
}

void GLists::ListTraverse(List L)//广义表遍历
{
    if(L->tag==ATOM)
    {
        cout<<L->atom<<",";
    }
    else
    {
        cout<<"(";
        while(L!=NULL)
        {
            ListTraverse(L->ptr.hp);
            L=L->ptr.tp;
        }
        cout<<")";
    }
}

int main()
{
    GLists gl;
    List l;
    gl.GetGList(l);

    cout<<gl.GListDepth(l)<<endl;
    cout<<gl.GListDepth(l)<<endl;

    //system("pause");
	return 0;
}