NYOJ467中缀式变后缀式

标签：c   存储   数据结构   算法   栈   

                                                                        中缀式变后缀式

描述

人们的日常习惯是把算术表达式写成中缀式，但对于机器来说更“习惯于”后缀式，关于算术表达式的中缀式和后缀式的论述一般的数据结构书都有相关内容可供参看，这里不再赘述，现在你的任务是将中缀式变为后缀式。

1. 输入
2. 第一行输入一个整数n，共有n组测试数据（n<10)。
   每组测试数据只有一行，是一个长度不超过1000的字符串，表示这个运算式的中缀式，每个运算式都是以“=”结束。这个表达式里只包含+-*/与小括号这几种符号。其中小括号可以嵌套使用。数据保证输入的操作数中不会出现负数。
   数据保证除数不会为0
3. 输出
4. 每组都输出该组中缀式相应的后缀式，要求相邻的操作数操作符用空格隔开。
5. 样例输入

6. 2
   1.000+2/4=
   ((1+2)*5+1)/4=

7. 样例输出

8. 1.000 2 4 / + =
   1 2 + 5 * 1 + 4 / =

9. 解题思路：逆波兰式算法的实现： 

*   首先分配两个stack，一个是临时存储运算符的stack s1(包含一个结束符号‘#‘)，一个作为输入逆波兰式的stack s2 
*   那么，首先s1开始的时候，push(‘#‘) 表示s1的结束标志 
*   <1> 如果取出的字符是‘(‘，push(‘(‘) 
*   <2> 如果取出的字符是‘)‘，将距离s1栈顶最近的‘(‘之间的字符依次出栈(不包含‘(‘)，然后送入s2,最后，将字符‘(‘出栈 
*   <3> 如果取出的是操作数，那么，将完整的操作数push s2(包括浮点数的小数点) 
*   <4> 如果取出的是运算符，那么，将该运算符与s1.top()的运算符的优先级比较，如果，大于栈顶运算符， 
*       那么push s1,否则，pop s1将运算符送入s2,至到栈顶运算符低于该运算符，那么，将该运算符push s1 
*   <5> 重复上面1~4的步骤，直到处理完所有的输入字符 
*   <6> 如果取出的字符是‘#‘，那么，将s1的所有的字符pop,然后依次送入s2 
*   注意：下面是具体的实现代码，根据题目的要求，使用字符串来模拟stack，实现的效果是一样的。 
*/ 转自： http://blog.csdn.net/sevenmit/article/details/9010035

代码如下：# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# define False 0
# define True 1

typedef struct node
 {
  char data;
  struct node *next;
 }LinkStackNode, *LinkStack;

int InitStack(LinkStack *S)           //初始化栈
{
  (*S) = (LinkStack)malloc(sizeof(LinkStackNode));
  (*S)->next = NULL;
  if ((*S) != NULL)
   return True;
  else
   return False;
 }

int Push(LinkStack S, char x)         //进栈
{
  LinkStack temp;
  temp = (LinkStack)malloc(sizeof(LinkStackNode));
  if (temp == NULL)
   return False;
  temp->data = x;
  temp->next  = S->next;
  S->next = temp;
  return True;
 }

int Pop(LinkStack S)        //出栈
{
  LinkStack temp;
  temp = S->next;
  if (temp == NULL)
   return False;
  S->next = temp->next;
  free(temp);
  return True;
 }
int top(LinkStack S)
{
 char e;
 e = S->next->data;
 return e;
}

 //*************************************************************************
int cmp(char ch)
{
 switch(ch)
 {
 case‘+‘:
 case‘-‘:return 1;
 case‘*‘:
 case‘/‘:return 2;
 default:return 0;
 }
}
void fun(char *a, char *b,LinkStack s)
{
 Push(s,‘#‘);
 int i = 0,j  = 0;
 while (i < strlen(a) - 1)
 {
  if (a[i] == ‘(‘)
  {
   Push(s,a[i]);
   i++;
  }
  else if (a[i] == ‘)‘)
  {
   while (top(s) !=  ‘(‘)
   {
    b[j] = top(s);
    b[j+1] = ‘ ‘;
    j+=2;
    Pop(s);
   }
   Pop(s);
   i++;
  }
  else if (a[i] == ‘+‘ || a[i] == ‘-‘ || a[i] == ‘*‘ || a[i] == ‘/‘)
  {
   while (cmp(top(s)) >= cmp(a[i]))
   {
    b[j] = top(s);
    b[j+1] = ‘ ‘;
    j+= 2;
    Pop(s);
   }
   Push(s,a[i]);
   i++;
  }
  else
  {
   while (‘0‘ <= a[i] &&a[i] <= ‘9‘ ||a[i] == ‘.‘)
   {
    b[j] = a[i];
    i++;j++;
   }
   b[j] = ‘ ‘;
   j++;
  }
 }
 while (top(s) != ‘#‘)
 {
  b[j] = top(s);
  b[j+1] = ‘ ‘;
  j += 2;
  Pop(s);
 }
 b[j] = ‘=‘;

}
int main(void)
{
 int n,i;
 char a[1001],b[2002];
 LinkStack S;
 scanf("%d", &n);
 while (n--)
 {
  InitStack(&S);
  scanf("%s", a);
  fun(a,b,S);
  i = 0;
  while (b[i] != ‘=‘)
  {
   printf("%c",b[i]);
   i++;
  }
  printf("=\n");
 }
 return 0;
}

NYOJ467中缀式变后缀式

标签：c   存储   数据结构   算法   栈   

原文地址：http://blog.csdn.net/java_oracle_c/article/details/41986941