NYOJ467中缀式变后缀式

中缀式变后缀式

时间限制:1000 ms  |  内存限制:65535 KB

难度:3

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

  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;

    }

    时间: 2024-10-17 05:12:36

    NYOJ467中缀式变后缀式的相关文章

    NYOJ467 中缀式变后缀式 【栈】

    中缀式变后缀式 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 人们的日常习惯是把算术表达式写成中缀式,但对于机器来说更"习惯于"后缀式,关于算术表达式的中缀式和后缀式的论述一般的数据结构书都有相关内容可供参看,这里不再赘述,现在你的任务是将中缀式变为后缀式. 输入 第一行输入一个整数n,共有n组测试数据(n<10). 每组测试数据只有一行,是一个长度不超过1000的字符串,表示这个运算式的中缀式,每个运算式都是以"="结束.这个

    中缀式变后缀式

    中缀式变后缀式 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 人们的日常习惯是把算术表达式写成中缀式,但对于机器来说更"习惯于"后缀式,关于算术表达式的中缀式和后缀式的论述一般的数据结构书都有相关内容可供参看,这里不再赘述,现在你的任务是将中缀式变为后缀式. 输入 第一行输入一个整数n,共有n组测试数据(n<10). 每组测试数据只有一行,是一个长度不超过1000的字符串,表示这个运算式的中缀式,每个运算式都是以"="结束.这个

    南阳OJ 中缀式变后缀式

     /*中缀式变后缀式 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 人们的日常习惯是把算术表达式写成中缀式,但对于机器来说更"习惯于"后缀式, 关于算术表达式的中缀式和后缀式的论述一般的数据结构书都有相关内容可供参看, 这里不再赘述,现在你的任务是将中缀式变为后缀式. 输入第一行输入一个整数n,共有n组测试数据(n<10). 每组测试数据只有一行,是一个长度不超过1000的字符串,表示这个运算式的中缀式, 每个运算式都是以"=&quo

    NYOJ 467 中缀式变后缀式

    做了表达式求值那道题之后做的 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 人们的日常习惯是把算术表达式写成中缀式,但对于机器来说更"习惯于"后缀式,关于算术表达式的中缀式和后缀式的论述一般的数据结构书都有相关内容可供参看,这里不再赘述,现在你的任务是将中缀式变为后缀式. 输入 第一行输入一个整数n,共有n组测试数据(n<10). 每组测试数据只有一行,是一个长度不超过1000的字符串,表示这个运算式的中缀式,每个运算式都是以"=&quo

    南阳 oj 中缀式变后缀式 题目467 数据结构 NYOj

     #include<stdio.h> #include<string.h> #include<stdlib.h> #define N 1000 using namespace std; char s[N];//存储字符串 char str1[N];//存储'o'-到'9'的字符 char str2[N];//存储运算符 int top1,top2;//利用数组模拟栈 int compare(char x)//优先级比较 { switch(x) { case '+'

    栈的应用 — 中缀式转后缀式

    由中缀式转换成后缀式,同样使用栈,并运用一些规则来完成.规则介绍如下: 当读到的是操作数,立即输出. 当读到的是运算符,则先从栈中弹出优先级高于自己的运算符(不包含括号),自己入栈. 读到左括号入栈,读到右括号则将栈中元素出栈并输出,直到遇见左括号(括号都不输出). 输入为空后,将栈元素弹出并输出直到栈空. 注意,最后生成的后缀表达式是考虑了运算符优先级的,再配合逆波兰的无优先级概念这一性质,就能够编写出一个带运算符优先级和括号的简易计算器了. 下面是完整的计算器代码,整型四则运算,可加括号.写

    [Code] 中缀式转后缀式

    [Code] 中缀式转后缀式 概要 对于一个可带括号的中缀四则运算表达式, 例如30 + 4 / 2 或 30 / ( 4 + 2 ), 下面代码将分别转换为对应的后缀表达形式 30 4 2 / + 和 30 4 2 + /. 要求每个 token 之间以若干个空白符隔开, 输入的中缀式为单行. 代码 import java.util.Scanner; import java.util.Deque; import java.util.ArrayDeque; import java.util.Ma

    恶补C++ 之 自增、自减操作符前缀式与后缀式的区别

    相信很多人刚开始学习编程的时候,也是为这个问题烦恼过吧,前缀式与后缀式,在很久之前,式没有办法区别++和--操作符的前缀和后缀的调用的.不过在C++已经得到了扩展. 然而无论式前缀或者后缀,都只有一个参数.为了解决这个问题,C++规定后缀形式有一个int类型的参数,当函数被调用的时候,编译器传递一个0作为int参数给该函数: class UPInt { public: UPInt& operator++();        // ++前缀 const UPInt operator++(int);

    算法题:四则运算(中缀式到后缀式的转换,值得思考的逆波兰式)

    /* 字符串的四则运算.给出一个字符串, 包含0~9的数字和 + -*\/ ()的运算符, - 仅代表减号不代表负数.举例如下: 输入:1 + 2 * (3 - 4) */ //哈哈,看到这道题,其实一点也不难,这个题根本就不用思考, //当然是你明白算法之后,这里要用到的算法是逆波兰式. //如果你有不明白的地方,可以上网搜逆波兰式. /* 我的总结:计算机无法理解人类的正向思维,于是为了满足计算机的 思维,我们会反其道而行之,将操作符号放在操作数的后面,形成后缀 表达式,但是如果你能按百科上