071.魔王语言翻译
        【摘要】 
                    #include   <stdio.h> #include   <string.h> #include   <stdlib.h> #include   <conio.h>  /*定义全局变量*/ #define   TRUE   1 #define   FALSE   0 #define ...
    
    
    
    
  
   - 
    
     
    
    
     
      #include <stdio.h> 
     
    
- 
    
     
    
    
     
      #include <string.h> 
     
    
- 
    
     
    
    
     
      #include <stdlib.h> 
     
    
- 
    
     
    
    
     
      #include <conio.h> 
     
    
- 
    
     
    
    
      
     
    
- 
    
     
    
    
     
      /*定义全局变量*/ 
     
    
- 
    
     
    
    
     
      #define TRUE 1 
     
    
- 
    
     
    
    
     
      #define FALSE 0 
     
    
- 
    
     
    
    
     
      #define OK 1 
     
    
- 
    
     
    
    
     
      #define ERROR 0 
     
    
- 
    
     
    
    
     
      #define NULL 0 
     
    
- 
    
     
    
    
     
      #define OVERFLOW -2 
     
    
- 
    
     
    
    
     
      #define MAXSIZE 100 
     
    
- 
    
     
    
    
     
      #define stack_init_size 100 
     
    
- 
    
     
    
    
     
      #define stackincrement 10 
     
    
- 
    
     
    
    
     
      typedef   char   selemType; 
     
    
- 
    
     
    
    
     
      typedef   char   qelemType; 
     
    
- 
    
     
    
    
     
      typedef   char   elemType; 
     
    
- 
    
     
    
    
     
      typedef   int   status; 
     
    
- 
    
     
    
    
     
      char   e;     
     
    
- 
    
     
    
    
     
      char   demon[MAXSIZE];
     
    
- 
    
     
    
    
          
     
    
- 
    
     
    
    
     
      /* 类型及其基本操作*/   
     
    
- 
    
     
    
    
     
      typedef   struct   
     
    
- 
    
     
    
    
     
      {   
     
    
- 
    
     
    
    
     
      	selemType   *base; 
     
    
- 
    
     
    
    
     
      	selemType   *top; 
     
    
- 
    
     
    
    
     	int   stacksize; 
     
    
- 
    
     
    
    
     
      }sqstack;     
     
    
- 
    
     
    
    
     
      status initstack (sqstack *s) 
     
    
- 
    
     
    
    
     
      {     
     
    
- 
    
     
    
    
     
      	s->base=(selemType   *)malloc(stack_init_size*sizeof(selemType));     
     
    
- 
    
     
    
    
     	if(!s->base)   exit   (OVERFLOW); 
     
    
- 
    
     
    
    
     
      	s->top=s->base; 
     
    
- 
    
     
    
    
     
      	s->stacksize=stack_init_size; 
     
    
- 
    
     
    
    
     	return   OK; 
     
    
- 
    
     
    
    
     
      }/*创建栈*/ 
     
    
- 
    
     
    
    
     
      status push (sqstack *s,selemType e) 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     	if(s->top-s->base>=s->stacksize) 
     
    
- 
    
     
    
    
     
      	{ 
     
    
- 
    
     
    
    
     
      		s->base=(elemType*)   realloc(s->base,(s->stacksize+stackincrement)*sizeof(elemType))     
     
    
- 
    
     
    
    
     		if(!s->base)   exit(OVERFLOW); 
     
    
- 
    
     
    
    
     
      		s->top=s->base+s->stacksize; 
     
    
- 
    
     
    
    
     
      		s->stacksize+=stackincrement; 
     
    
- 
    
     
    
    
     
      	} 
     
    
- 
    
     
    
    
     
      	*(s->top++)=e; 
     
    
- 
    
     
    
    
     	return   OK; 
     
    
- 
    
     
    
    
     
      }/*入栈*/ 
     
    
- 
    
     
    
    
     
      status pop(sqstack *s,selemType *e) 
     
    
- 
    
     
    
    
     
      {     
     
    
- 
    
     
    
    
     	if(s->top==s->base)   return   ERROR; 
     
    
- 
    
     
    
    
     
      	*e=*(--(s->top)); 
     
    
- 
    
     
    
    
     	return   OK; 
     
    
- 
    
     
    
    
     
      }/*出栈*/ 
     
    
- 
    
     
    
    
     
      /*队列类型及其基本操作*/ 
     
    
- 
    
     
    
    
     
      typedef   struct   qnode 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     
      	qelemType   data; 
     
    
- 
    
     
    
    
     	struct   qnode   *next; 
     
    
- 
    
     
    
    
     
      }qnode,*queueptr; 
     
    
- 
    
     
    
    
     
      typedef   struct 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     
      	queueptr   front; 
     
    
- 
    
     
    
    
     
      	queueptr   rear; 
     
    
- 
    
     
    
    
     
      }linkqueue; 
     
    
- 
    
     
    
    
     
      status initqueue(linkqueue *q) 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     
      	q->front=q->rear=(queueptr)malloc(sizeof(qnode)); 
     
    
- 
    
     
    
    
     	if(!q->front)   exit(OVERFLOW); 
     
    
- 
    
     
    
    
     
      	q->front->next=NULL; 
     
    
- 
    
     
    
    
     	return   OK; 
     
    
- 
    
     
    
    
     
      }/*创建队列*/ 
     
    
- 
    
     
    
    
     
      status enqueue(linkqueue *q,qelemType e) 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     
      	queueptr   p; 
     
    
- 
    
     
    
    
     
      	p=(queueptr)malloc(sizeof(qnode)); 
     
    
- 
    
     
    
    
     	if(!p)   exit(OVERFLOW); 
     
    
- 
    
     
    
    
     
      	p->data=e; 
     
    
- 
    
     
    
    
     
      	p->next=NULL; 
     
    
- 
    
     
    
    
     
      	q->rear->next=p; 
     
    
- 
    
     
    
    
     
      	q->rear=p; 
     
    
- 
    
     
    
    
     	return   OK; 
     
    
- 
    
     
    
    
     
      }/*入队*/ 
     
    
- 
    
     
    
    
     
      status dequeue(linkqueue *q,qelemType *e) 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     
      	queueptr   p; 
     
    
- 
    
     
    
    
     	if(q->front==q->rear)   return   ERROR; 
     
    
- 
    
     
    
    
     
      	p=q->front->next; 
     
    
- 
    
     
    
    
     
      	*e=p->data; 
     
    
- 
    
     
    
    
     
      	q->front->next=p->next; 
     
    
- 
    
     
    
    
     	if(q->rear==p) 
     
    
- 
    
     
    
    
     
      	{ 
     
    
- 
    
     
    
    
     
      		q->rear=q->front; 
     
    
- 
    
     
    
    
     
      	} 
     
    
- 
    
     
    
    
     	free(p);
     
    
- 
    
     
    
    
     	return   OK;
     
    
- 
    
     
    
    
     
      }/*出队*/ 
     
    
- 
    
     
    
    
      /*括号内元素入栈处理函数*/
     
    
- 
    
     
    
    
     
      void tempstack(sqstack *temps) 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     	int   i=0; 
     
    
- 
    
     
    
    
     	char   t; 
     
    
- 
    
     
    
    
     	char   c;
     
    
- 
    
     
    
    
     
      	c=demon[i];
     
    
- 
    
     
    
    
     	for(i=0;c!='#';i++)/*遍历数组*/
     
    
- 
    
     
    
    
     
      	{
     
    
- 
    
     
    
    
     
      		c=demon[i];
     
    
- 
    
     
    
    
     		if(c=='(')/*遇到开括号*/
     
    
- 
    
     
    
    
     
      		{
     
    
- 
    
     
    
    
     
      			t=demon[i+1];/*取括号中的首字母*/
     
    
- 
    
     
    
    
     			push(temps,t);/*入栈*/
     
    
- 
    
     
    
    
     
      			i++;/*指向首字母*/
     
    
- 
    
     
    
    
     			do 
     
    
- 
    
     
    
    
     
      			{ 
     
    
- 
    
     
    
    
     
      				i++; 
     
    
- 
    
     
    
    
     
      				c=demon[i]; 
     
    
- 
    
     
    
    
     				push(temps,c)/*第一次循环将次字母入栈*/; 
     
    
- 
    
     
    
    
     				push(temps,t);/*再将首字母进栈*/ 
     
    
- 
    
     
    
    
     
      			}while(c!=')');/*直到括号中元素全部进栈*/ 
     
    
- 
    
     
    
    
     			pop(temps,&t);/*将多余进栈的首字母t出栈*/ 
     
    
- 
    
     
    
    
     			pop(temps,&t);   /*将多余进栈的')'出栈*/ 
     
    
- 
    
     
    
    
     
      		} 
     
    
- 
    
     
    
    
     
      	} 
     
    
- 
    
     
    
    
     
      }/*临时栈*/ 
     
    
- 
    
     
    
    
      
     
    
- 
    
     
    
    
      /*特殊入队函数*/
     
    
- 
    
     
    
    
     
      void spenqueue(linkqueue *q,char key) 
     
    
- 
    
     
    
    
     
      {     
     
    
- 
    
     
    
    
     	int   j=0;
     
    
- 
    
     
    
    
     	char   a[5]; 
     
    
- 
    
     
    
    
     	switch(key)   /*判断大写字母对应的字符串*/ 
     
    
- 
    
     
    
    
     
      	{ 
     
    
- 
    
     
    
    
     	case'A':strcpy(a,"ase");break; 
     
    
- 
    
     
    
    
     	case'B':strcpy(a,"tAdA");break;
     
    
- 
    
     
    
    
     	case'C':strcpy(a,"abc");break; 
     
    
- 
    
     
    
    
     	case'D':strcpy(a,"def");break; 
     
    
- 
    
     
    
    
     	case'E':strcpy(a,"ghi");break; 
     
    
- 
    
     
    
    
     	case'F':strcpy(a,"klm");break; 
     
    
- 
    
     
    
    
     	case'H':strcpy(a,"mop");break; 
     
    
- 
    
     
    
    
     	default:strcpy(a,"???");   /*不能翻译的魔王语言以"???"输出*/ 
     
    
- 
    
     
    
    
     
      	} 
     
    
- 
    
     
    
    
     	while(a[j]!='\0')   /*如果数组还有字母*/ 
     
    
- 
    
     
    
    
     
      	{ 
     
    
- 
    
     
    
    
     		enqueue(q,a[j]);/*进队*/ 
     
    
- 
    
     
    
    
     
      		j++; 
     
    
- 
    
     
    
    
     
      	} 
     
    
- 
    
     
    
    
     
      }/*特殊入队*/ 
     
    
- 
    
     
    
    
     
      /*排序入队处理函数*/ 
     
    
- 
    
     
    
    
     
      status sort(sqstack *s,linkqueue *q) 
     
    
- 
    
     
    
    
     
      {     
     
    
- 
    
     
    
    
     
      	qnode   b; 
     
    
- 
    
     
    
    
     	int   flag=0;/*大写字母监视哨置零*/ 
     
    
- 
    
     
    
    
     	int   i; 
     
    
- 
    
     
    
    
     	for(i=0;demon[   i]!='#';i++)/*遍历数组*/ 
     
    
- 
    
     
    
    
     
      	{ 
     
    
- 
    
     
    
    
     
      		b.data=demon[   i]; 
     
    
- 
    
     
    
    
     		if(   ('a'<=b.data&&b.data<='z')||b.data=='?')   /*如果是小写字母或者'?' 则直接进栈*/     
     
    
- 
    
     
    
    
     
      		{ 
     
    
- 
    
     
    
    
     			enqueue(q,b.data); 
     
    
- 
    
     
    
    
     
      		} 
     
    
- 
    
     
    
    
     		else 
     
    
- 
    
     
    
    
     
      		{ 
     
    
- 
    
     
    
    
     			if('A'<=b.data&&b.data<='Z')   /*如果是大写字母,则调用特殊进栈函数,*/     
     
    
- 
    
     
    
    
     
      			{ 
     
    
- 
    
     
    
    
     				spenqueue(q,b.data); 
     
    
- 
    
     
    
    
     
      				flag=1;   /*发现大写字母监视哨置1*/ 
     
    
- 
    
     
    
    
     
      			} 
     
    
- 
    
     
    
    
     			else 
     
    
- 
    
     
    
    
     
      			{ 
     
    
- 
    
     
    
    
     				if(b.data=='(')/*如果是括号*/ 
     
    
- 
    
     
    
    
     
      				{
     
    
- 
    
     
    
    
     					do 
     
    
- 
    
     
    
    
     
      					{ 
     
    
- 
    
     
    
    
     						pop(s,&e); 
     
    
- 
    
     
    
    
     						enqueue(q,e); 
     
    
- 
    
     
    
    
     
      					}while(!(s->top==s->base));   /*只要栈不为空,则出栈进队*/     
     
    
- 
    
     
    
    
     					while   (b.data!=')')   /*只要还指向括号内元素,就继续往后移,保证原括号内的元素不再进栈*/ 
     
    
- 
    
     
    
    
     
      					{ 
     
    
- 
    
     
    
    
     
      						i++; 
     
    
- 
    
     
    
    
     
      						b.data=demon[i]; 
     
    
- 
    
     
    
    
     
      					} 
     
    
- 
    
     
    
    
     
      				} 
     
    
- 
    
     
    
    
     
      			} 
     
    
- 
    
     
    
    
     
      		} 
     
    
- 
    
     
    
    
     
      	}
     
    
- 
    
     
    
    
     	return   flag; 
     
    
- 
    
     
    
    
     
      }/*排序*/
     
    
- 
    
     
    
    
     
      /*主函数*/
     
    
- 
    
     
    
    
     
      status main() 
     
    
- 
    
     
    
    
     
      { 
     
    
- 
    
     
    
    
     
      	sqstack   s1; 
     
    
- 
    
     
    
    
     
      	linkqueue   q1; 
     
    
- 
    
     
    
    
     	int   k=0; 
     
    
- 
    
     
    
    
     	int   flag=1; 
     
    
- 
    
     
    
    
     	clrscr(); 
     
    
- 
    
     
    
    
     	printf("Please Input the Demon's Words:\n"); 
     
    
- 
    
     
    
    
     	printf("!: Less Than 30 Letters: )\n"); 
     
    
- 
    
     
    
    
     	printf("!: End with '#': )\n\t"); 
     
    
- 
    
     
    
    
     	scanf("%s",demon);
     
    
- 
    
     
    
    
     	printf("\n***************************************"); 
     
    
- 
    
     
    
    
     	initstack(&s1);   /*创建栈*/ 
     
    
- 
    
     
    
    
     	initqueue(&q1);   /*创建队*/ 
     
    
- 
    
     
    
    
     	tempstack(&s1);   /*调用函数*/ 
     
    
- 
    
     
    
    
     	while   (flag==1)   /*如果有大写字母*/ 
     
    
- 
    
     
    
    
     
      	{ 
     
    
- 
    
     
    
    
     
      		k=0; 
     
    
- 
    
     
    
    
     
      		flag=sort(&s1,&q1); 
     
    
- 
    
     
    
    
     		while(q1.front!=q1.rear)   /*重写demon[i ]*/ 
     
    
- 
    
     
    
    
     
      		{ 
     
    
- 
    
     
    
    
     			dequeue(&q1,&e); 
     
    
- 
    
     
    
    
     
      			demon[k]=e;
     
    
- 
    
     
    
    
     
      			k++;
     
    
- 
    
     
    
    
     
      		}
     
    
- 
    
     
    
    
     
      		demon[k]='#';
     
    
- 
    
     
    
    
     
      	}
     
    
- 
    
     
    
    
     
      	demon[k]='\0';
     
    
- 
    
     
    
    
     	printf("\n***************************************");
     
    
- 
    
     
    
    
     	printf("\nThe Human Words:\n\t%s",demon);
     
    
- 
    
     
    
    
     	printf("\n***************************************");
     
    
- 
    
     
    
    
     
      }
     
    
 文章来源: blog.csdn.net,作者:程序员编程指南,版权归原作者所有,如需转载,请联系作者。
原文链接:blog.csdn.net/weixin_41055260/article/details/124518266
        【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱:
            cloudbbs@huaweicloud.com
        
        
        
        
        
        
        - 点赞
- 收藏
- 关注作者
 
             
           
评论(0)