当前位置: 代码迷 >> C语言 >> 求救:大家帮忙改改我的程序。
  详细解决方案

求救:大家帮忙改改我的程序。

热度:520   发布时间:2008-06-26 11:29:51.0
求救:大家帮忙改改我的程序。
只是一些逻辑上的错误,是建立广义表,输入命令串,求表头和表尾。

识别广义表的头或尾
【问题描述】
写一个程序,建立广义表的存储结构,演示在此存储结构上实现的广义表求头/求尾操作序列的结果。
【基本要求】
(1) 设一个广义表允许分多行输入,其中可以任意地输入空格符,原子是不限长的仅由字母或数字组成的串。
(2) 广义表采用如教科书中图5.8所示结点的存储结构,试按表头和表尾的分解方法编写建立广义表存储结构的算法。
(3) 对已建立存储结构的广义表施行操作,操作序列为一个仅由"t"或"h"组成的串,它可以是空串(此时印出整个广义表),自左至右施行各操作,
再以符号形式显示结果。


#include<Lisths.h>/*各个包含函数*/
#include<ListUnit.h>/*广义表的类型定义*/
void InitGList(GList Ls);
/* 初始化广义表Ls为空表,Ls==NULL */
void CreateGList(GList Ls);
/* 由计算机终端输入广义表的书写串,边读入边建立广义表Ls的存储结构。 */
void  DestroyGList(GList Ls);
/* 销毁广义表Ls的结构,同时释放结点空间 */
Status  GListEmpty(GList  Ls);
/* 若广义表Ls为空表,则返回TURE,否则返回FALSE */
GList  GetHead(GList  Ls);
/* 若广义表Ls为非空,则返回其表头Ls->hp,否则返回null(无实际含义) */
GList  GetTail(GList  Ls);
/* 若广义表Ls为非空,则返回其表尾Ls->tp,否则返回null(无实际含义) */
void Traverse_GL(GList  Ls);
/* 遍历广义表Ls,以书写的形式输出到终端 */
void Inintialization();
/* 初始化函数 */
void ReadCommand(char ch);
/* 读入操作命令符 */
void Interpret(char ch);
/* 解释操作命令符 */
void Decompose(GList Hlink,char str[]);
/*  解释命令串str,对广义表Hlink执行“求表头”或“求表尾”的操作,
并求出每一步的操作后求得的广义表的表头和表尾的字符串 */
/*  ReadCommand();     */
/* 读入一个操作的命令符 */
GList  Hlink,p,Ls,q1,q2;   int i;
char ch;
void main()
{  /* 主函数 */
   char ch;
  Inintialization();   /* 初始化 */
do
    {scanf("%c",&ch);
     printf("%c",ch);
    /* ReadCommand(); */     /* 读入一个操作的命令符 */
     Interpret(ch);           /* 解释执行的操作命令符 */
    }while(ch!='q'&&'Q');
}



void Inintialization()
{
  printf("***********************************************************\n");
  printf(" CreateGList:c     Decompose:  d       Quit      q\n\n");
  printf(" Enter a operation code:c/C   d/D   q/Q\n");
  printf("***********************************************************\n");
  InitGList(Hlink);  /* 初始化广义表为空表 */
}
void InitGList(GList Ls)
{ /* 创建空的广义表L */
   Ls=NULL;
}


/*  void ReadCommand() */
/* {  /*读入操作命令符  显示键入的操作命令符的提示信息; */ */
/*   scanf("%c",&ch); */
/*  printf("%c",ch); */
/*  } */


void Interpret(char ch)
{char str[10];
int i;
printf("The command you input is :\n");
scanf("%c",&ch);
printf("%c",ch);
switch(ch)
        {
     case 'c':  printf("Please input char creat list:\n");
                             CreateGList(Hlink);    /* 创建广义表的存储结构输出广义表存储结构建立完毕的信息; */
                      break;
     case 'd': /* 提示用户输入广义表的表头或者表尾的命令串str; */
              if(GListEmpty(Hlink))       /* 广义表为空表 提示用户重新的输入广义表 */
                       {
                          printf("The list is NULL,Please create:\n");
                          CreateGList(Ls);
                       }
                      else  printf("Input your operation string:\n");
                      for(i=0;i<10;i++)
                        scanf("%c",&str[i]);
                      for(i=0;i<10;i++)
                        printf("%c",str[i]);
                     Decompose(Hlink,str);  /* 解释命令串并输出执行相应的命令后的信息 */
                        break;
     case 'q': break;   /* 退出 */
        }
}

void  CreateGList(GList Ls)
{char ch;
/* 本算法识别一个待输入的广义表的字符串,其中单字母表示原子(其中的字母不论大小写) */
/* 建立相应的存储结构,Ls为指向第一个节点的指针,若输入字符串为“()”, */
/* 则广义表为空表,即Ls=NULL. */
printf("Now input char creat list:\n");
scanf("%c",&ch);  /* 进入第一个符合要求的字符 */
if(ch!='(')   printf("ERROR!");  /* 广义表的第一个字符只能是’(’ */
else
crtLtBU(Ls);
}


crtLtBU(GList Ls)
{ char ch;
/* 本算法识别一个待输入的从字符’(’或者’,’之后的广义表中的字符串,并建立相应的存储结构 */
scanf("%c",&ch);  /* 进入第一个合法的字符 */
if(ch==' ')   /* 广义表为空表的情况 */
{
    Ls==NULL;
   scanf("%c",&ch);     /*  下一个的合法的字符应该是’)’ */
    if(ch!=')')  return ERROR;
}
      else
{
/*  当前输入的广义表非空 */
    Ls=(GLNode *)malloc(sizeof(GLNode));
    Ls->tag=LIST;
    if(ch>64&&ch<91&&ch>96&&ch<123)
    { /*  表头为单原子 */
     Ls->a.ptr.hp=*(GList *)malloc(sizeof(GLNode));
     p=Ls->a.ptr.hp; Ls->tag=ATOM;
     Ls->a.atom=ch;
    }
    else if (ch=='(')   crtLtBU(Ls->a.ptr.hp);  /* 表头为广义表 */
    else
          return ERROR; /*  其他的字符均为出错的情况 */
    scanf("%c",&ch);   /* 进入下一个合法的字符   */
     if(ch!=')')
            Ls->a.ptr.tp=NULL;    /* 广义表或者其中的一个字表输入结束 */
   else if (ch==',')   crtLtBU(Ls->a.ptr.tp);  /* 当前的表尾不空,等待输入下一个子表 */
   else return ERROR;   /* 当前的这个字符只能是’,’或者’)’两种情况 */
}
}


void Traverse_GL(GList  Ls)
{/*  遍历广义表Ls,以书写的形式输出到终端 */
    if(!Ls) printf("( )");
    else
        if(Ls->tag==ATOM)   printf("%c", Ls->a.ptr.atom);  /* 输出单原子 */
        else
            {
                printf("(");
                while(Ls!=NULL)
                    {
             Traverse_GL(GetHead(Ls));
             Ls=GetTail(Ls);
                  if(Ls)      
                            printf(",");  /* 表尾不空,输出字符’,’ */
                    }
                    printf(")");      /* 当层遍历结束,输出字符’)’ */
            }
}
void DestroyGList(GList Ls)
{ /* 销毁广义表L */
   GList q1,q2;
   if(Ls)
   {
     if((Ls)->tag==LIST) /* 删除表结点 */
     {
       q1=Ls->a.ptr.hp; /* q1指向表头 */
       q2=Ls->a.ptr.tp; /* q2指向表尾 */
       DestroyGList(q1); /* 销毁表头 */
       DestroyGList(q2); /* 销毁表尾 */
     }
     free(Ls);
     Ls=NULL;
   }
}

Status GListEmpty(GList Ls)
{ /* 判定广义表是否为空 */
   if(!Ls)
     return TRUE;
   else
     return FALSE;
}


void Decompose(GList Hlink,char str[])
{
/*  解释命令串str,对广义表Hlink执行“求表头”或“求表尾”的操作,并求出每一步的操作后求得的广义表的表头和表尾的字符串 */
   GList p=Hlink;
    int i;
    for(i=0;i<10;i++)
        {
          if(!p)   printf("The LIST is a EmptyList!");
          else
            {
          if(str[i]=='h')
                { p=GetHead(p);  
                    printf("The ListHead is ");
                }
          else if(str[i]=='t')
                {p=GetTail(p);  
                 printf("The ListTail is  ");
                }
              Traverse_GL(p);
            }
        }
}
GList GetHead(GList Ls)
{ /* 生成广义表Ls的表头元素,返回指向这个元素的指针 */
   GList p;
   if(!Ls) /* 空表无表头 */
     return NULL;
   p=Ls->a.ptr.hp; /* p指向Ls的表头元素 */
   return p;
}


GList GetTail(GList Ls)
{ /* 将广义表Ls的表尾生成为广义表,返回指向这个新广义表的指针 */
   GList p;
   if(!Ls) /* 空表无表尾 */
     return NULL;
   p=Ls->a.ptr.tp; /* p指向Ls的表尾元素 */
   return p;
}



ListUnit.h
 typedef enum{ATOM,LIST}ElemTag; /* ATOM==0:原子,LIST==1:子表 */
typedef char AtomType;
typedef struct GLNode
{
   ElemTag tag; /* 公共部分,用于区分原子结点和表结点 */
   union /* 原子结点和表结点的联合部分 */
   {
     AtomType atom; /* atom是原子结点的值域,AtomType由用户定义 */
     struct
     {
       struct GLNode *hp,*tp;
     }ptr; /* ptr是表结点的指针域,prt.hp和ptr.tp分别指向表头和表尾 */
   }a;
}*GList,GLNode; /* 广义表类型 */



/* Lisths.h (程序名) */
#include<string.h>
#include<ctype.h>
#include<malloc.h> /* malloc()等 */
#include<limits.h> /* INT_MAX等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<stdlib.h> /* atoi() */
#include<io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */
#include<process.h> /* exit() */
/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */


[[it] 本帖最后由 雪山脚下 于 2008-6-26 11:48 编辑 [/it]]

[[it] 本帖最后由 雪山脚下 于 2008-6-26 12:11 编辑 [/it]]
搜索更多相关的解决方案: 广义表  表尾  GList  表头  计算机  

----------------解决方案--------------------------------------------------------
  相关解决方案