数据结构广义表实验

一、问题描述：

1、题目内容：识别广义表的“头”或“尾”的演示

写一个程序，建立广义表的存储结构，演示在此存储结构上实现的广义表求头/求尾操作序列的结果。

2、基本要求

（1）设一个广义表允许分多行输入，其中可以任意地输入空格符，原子是不限长的仅字母或数字组成的串。

（2）广义表采用如教材中结点的存储结构，试按表头和表尾的分解方法编写建立广义表存储结构的算法。

（3）对已建立存储结构的广义表施行操作，操作序列为一个仅由“t“或”h”组成的串，它可以是空串（此时印出整个广义表），自左至右施行各操作，再以符号形式显示结果。

代码：

//panda
//2013-4-24

typedef char ElemType;

//定义结点
struct GLNode
{
    bool tag;//标志域
    union 
    {
        ElemType data;
        GLNode* sublist;
    };
    GLNode* next;//指向后续结点指针域
};

class GList
{
//private:
public:
    GLNode* head;
    //int length,depth;难以维护

    //输入字符串的左右括号数量
    int ifinputover;  //左括号+1，右括号-1
    //debug
    int i;
public:
    GList();
    ~GList();
public:
    int GetLength(GLNode* gl);
    int GetDepth(GLNode* gl);
    void CreateGListByInput(GLNode*& gl);////// 
    void ClearGList();//清除广义表
    void PrintGList(GLNode* gl);//输入广义表
    GLNode* PrintHeadNode(GLNode* head);//h操作
    GLNode* PrintTailNode(GLNode* tail);//t操作
};
//panda
//2013-4-24


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

//
//构造函数
//
GList::GList()
{
    head=NULL;
    //length=depth=0;
    ifinputover=0;
    //debug
    i=0;
};
//
//析构函数
//
GList::~GList()
{
    ClearGList();
};
//
//通过输入构建广义表
//ok     ///以#结束输入///       真正的广义表指针是gl->sublist
//广义表的头指针需要处理head=gl->sublist;
void GList::CreateGListByInput(GLNode*& gl)
{
    //debug
    //int i=0;//
    ++i;//每调用一次加1  表示是第几次调用

    char ch;
    //读入一个字符，这里可能是‘（’,字符
    cin>>ch;
    //建立结点，并构造子表
    if (ch=='(')
    {
        ++ifinputover;//左括号数量+1
        gl=new GLNode();
        gl->tag=true;//结点为子表
        CreateGListByInput(gl->sublist);
    }else if (ch==')')//这里遇到），则表明为空表
    {
        --ifinputover;//右括号+1
        //子表的结束
        gl=new GLNode();
        gl->tag=false;
        gl->data=NULL;
        gl->next=NULL;
        //debug
        --i;
        return;
    }else//不是子表，输入数据/////////////    )?
    {
        gl=new GLNode();
        gl->tag=false;
        gl->data=ch;
    }

    if (ifinputover)//没结束输入 
    {
        //此处输入的字符可能为')',','
        cin>>ch;
    }else  //输入完毕
    {
        gl->next=NULL;
        --i;
        return ;
    }

    //若为，则递归构造后续表
    if (ch==',')
    {
        CreateGListByInput(gl->next);
    }else if (ch==')')
    {
        --ifinputover;
        gl->next=NULL;
        //debug
        //--i;
        //return;
    }
    //debug
    --i;//回到调用前的数值
};
//
//获得广义表深度
//
int GList::GetDepth(GLNode* gl)
{
    //return depth;
    int max=0;
    while (gl!=NULL)
    {
        if (gl->tag=true)
        {
            int dep=GetDepth(gl->sublist);
            if (dep>max)
            {
                max=dep;
            }
        }
        gl=gl->next;
    }
    return max+1;
};
//
//获得广义表的长度
//
int GList::GetLength(GLNode* gl)
{
    //return length;
    if (gl!=NULL)
    {
        return 1+GetLength(gl->next);
    }else
    {
        return 0;
    }
};
//
//清空广义表
//
void GList::ClearGList()
{

};
//
//打印广义表
//ok
void GList::PrintGList(GLNode* gl)
{
    if (gl->tag==true)
    {
        cout<<'(';
        //输入子表
        if (gl->sublist==NULL)
        {
            //output nothinig
        }else
        {
            PrintGList(gl->sublist);
        }
        cout<<')';
    }else//输入数据结点
    {
        cout<<gl->data;
    }
    if (gl->next!=NULL)
    {
        cout<<',';
        PrintGList(gl->next);
    }
};
//
//h操作
//ok
GLNode* GList::PrintHeadNode(GLNode* head)
{
    if (head==NULL)
    {
        return NULL;
    }
    //deal glist
    if (head->tag==true)
    {
        if (head->sublist->tag==true)
        {
            if(head->sublist->next!=NULL)
            {
                head->sublist->next=NULL;
            }else
            {
                head=head->sublist;
            }
        }

    }else if (head->tag==false)
    {
        head->next=NULL;
    }

    //output glist
    PrintGList(head);
    cout<<',';

    if (head->tag==true)
    {
        if (head->sublist->tag==false&&head->next==NULL)
        {
            return head;
        }
        return head->sublist;
    }else if (head->tag==false)
    {
        return NULL;
    }
};
//
//t操作
//ok
GLNode* GList::PrintTailNode(GLNode* tail)
{
    if (tail==NULL)
    {
        return NULL;
    }
    //deal glist
    if (tail->tag==true)
    {
        if (tail->sublist->tag==true)
        {
            if (tail->sublist->next!=NULL)
            {
                //前移一个结点
                tail->sublist=tail->sublist->next;
            }else
            {
                tail=tail->sublist;
            }
        }else if (tail->sublist->tag==false)
        {
            tail->sublist=tail->sublist->next;
        }

    }else if (tail->tag==false)
    {
        tail=tail->next;
    }

    //output glist
    PrintGList(tail);
    cout<<',';


    if (tail->tag==true)
    {
        if (tail->sublist->tag==true&&tail->sublist->next==NULL)
        {
            return tail;
        }else if (tail->sublist->tag==true&&tail->sublist->next!=NULL)
        {
            //tail->sublist
            return tail;
        }
        return tail->sublist;
    }else if (tail->tag==false)
    {
        return NULL;
    }
};
/////////////////////////////////
//递归函数，只能一步一步的调试了

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

void InputString(char *ch,int size)
{
    cin.ignore(1);
    char temp;
    int i=0;
    while (temp=getchar())
    {
        if (temp=='\n')
        {
            ch[i]='\0';
            return;
        }
        if (i<size)
        {
            ch[i++]=temp;
        }else
        {
            return;
        }
    }
};

int main()
{
    GList glist;
    cout<<"input the GList:";
    glist.CreateGListByInput(glist.head);
    cout<<"PrintGList:";
    glist.PrintGList(glist.head);
    cout<<endl<<"请输入对广义表的操作序列(回车结束输入):";
    GLNode* temp=glist.head;
    char ch[50];
    InputString(ch,50);
    //operate glist
    char tempch;
    for (int i = 0; i < 50; i++)
    {
        tempch=ch[i];
        if (tempch=='h'||tempch=='H')
        {
            temp=glist.PrintHeadNode(temp);
        }else if (tempch=='t'||tempch=='T')
        {
            temp=glist.PrintTailNode(temp);
        }else if (tempch=='\0')
        {
            break;
        }else
        {
            cout<<"input error.";
            break;
        }
    }

    system("pause");
    return 0;
}