数据结构之 栈和队列---算术表达式的转换(前缀+中缀+后缀)

算术表达式的转换

Time Limit: 1000MS Memory limit: 65536K

题目描述

小明在学习了数据结构之后,突然想起了以前没有解决的算术表达式转化成后缀式的问题,今天他想解决一下。

因为有了数据结构的基础小明很快就解出了这个问题,但是他突然想到怎么求出算术表达式的前缀式和中缀式呢?小明很困惑。聪明的你帮他解决吧。

输入

输入一算术表达式,以\‘#\‘字符作为结束标志。(数据保证无空格,只有一组输入)

输出

输出该表达式转换所得到的前缀式 中缀式 后缀式。分三行输出,顺序是前缀式 中缀式 后缀式。

示例输入

a*b+(c-d/e)*f#

示例输出

+*ab*-c/def
a*b+c-d/e*f
ab*cde/-f*+

 写完这个代码,想死的心都有了,修了半天的bug 代码:
#include <string>
#include <iostream>
#include<stdio.h>
#include<string.h>
#include <algorithm>
#include <queue>
#include <stack>

using namespace std;

int cmp(char ch) //给运算符定义一个数值表示优先级大小
{
    if(ch==‘+‘ || ch==‘-‘)
      return 1;
    else if(ch==‘*‘ || ch==‘/‘ )
      return 2;
    else if(ch==‘)‘ || ch==‘(‘ )
      return 3; //括号的优先级最高
}

void Pre(char s[], int len )
{
    int i, j;
    char a[200]; int e=0;
    for(i=len-2; i>=0; i--)
    {
        a[e++]=s[i];
    }
    stack<char>ff;
    stack<char>gg;
    char dd;

    for(i=0; i<e; i++)
    {
        if(a[i]>=‘a‘ && a[i]<=‘z‘)
        {
            ff.push(a[i]);
        }
        else //如果是运算符的?
        {
            if(a[i]==‘)‘)
              gg.push(a[i]);
            else if( a[i]==‘(‘ )
            {

                while(gg.top()!=‘)‘ )
                {
                    dd=gg.top();
                    gg.pop();
                    ff.push(dd);
                }
                gg.pop();
            }
            else  // + - * /
            {
                if( !gg.empty() && (cmp(gg.top() )> cmp(a[i])) ) //栈顶元素优先级大
                {
                    if(gg.top()==‘)‘)
                    {
                        gg.push(a[i]);
                    }
                    else
                    {
                        dd=gg.top();
                        gg.pop();
                        ff.push(dd);
                        gg.push(a[i]);
                    }
                }
                else
                {
                    gg.push(a[i]);
                }
            }
        }
    }
    while(!gg.empty())
    {
        dd=gg.top();
        ff.push(dd);
        gg.pop();
    }
    while(!ff.empty())
    {
        dd=ff.top();
        cout<<dd;
        ff.pop();
    }
    cout<<endl;
}

void In(char s[], int len)
{
    int i;
    for(i=0; i<len-1; i++)
    {
        if(s[i]==‘(‘ || s[i]==‘)‘)
          continue;
        else
          cout<<s[i];
    }
    cout<<endl;
}

void Post(char s[], int len)
{
     stack<char>q;
     int i;

    for(i=0; i<len-1; i++)
    {
        if(s[i]>=‘a‘ && s[i]<=‘z‘)
        {
            cout<<s[i];
        }
        else
        {
            if(q.empty())
            {
                q.push(s[i]);
            }
            else //栈非空
            {
                if(s[i]==‘(‘)
                {
                    q.push(s[i]);
                }
                else if(s[i]==‘+‘)
                {
                    if(q.top()==‘(‘ )
                    {
                        q.push(s[i]);
                    }
                    else
                    {
                        cout<<q.top();
                        q.pop();
                        q.push(s[i]);
                    }
                }
                else if(s[i]==‘-‘)
                {
                    if(q.top()==‘(‘)
                    {
                        q.push(s[i]);
                    }
                    else
                    {
                        cout<<q.top();
                        q.pop();
                        q.push(s[i]);
                    }
                }
                else if(s[i]==‘*‘)
                {
                    if(q.top()==‘(‘ || q.top()==‘+‘ || q.top()==‘-‘ )
                    {
                        q.push(s[i]);
                    }
                    else
                    {
                        cout<<q.top();
                        q.pop();
                        q.push(s[i]);
                    }
                }
                else if(s[i]==‘/‘)
                {
                    if(q.top()==‘+‘ || q.top()==‘-‘ || q.top()==‘(‘)
                    {
                        q.push(s[i]);
                    }
                    else
                    {
                        cout<<q.top();
                        q.pop();
                        q.push(s[i]);
                    }
                }
                else if(s[i]==‘)‘)
                {
                    while(q.top()!=‘(‘)
                    {
                        cout<<q.top();
                        q.pop();
                    }
                    q.pop(); //将左括号弹出
                }

            }
        }
    }
    while(!q.empty())
    {
        cout<<q.top();
        q.pop();
    }
}

int main()
{
    char s[200];
    int len;
    int i, j;
    scanf("%s", s);
    len=strlen(s);
    Pre(s, len);
    In(s, len);
    Post(s, len);
    cout<<endl;

    return 0;
}
  
时间: 2024-08-26 22:59:01

数据结构之 栈和队列---算术表达式的转换(前缀+中缀+后缀)的相关文章

【数据结构】栈和队列

栈和队列 容器数据结构是指一些包含了若干个其他相同或不同的数据结构的数据结构,被包含的这些每一个独立的数据结构都被称为一个元素,在一个容器中的元素往往支持相同的操作,具有类似的性质.之前说到过的线性表其实就是一种容器数据结构,本文中介绍的两种最常用的容器数据结构是栈和队列. 从功能上看,栈和队列大多用于计算过程中保存临时数据,这些数据是在计算过程中发现或产生的.在而后的计算中可能会用到这些数据.如果这些数据是固定的个数以及大小的话,可以构建几个变量来储存它们,但是如果这些数据不确定的话,就需要一

SDUTOJ 2484 算术表达式的转换(栈)

算术表达式的转换 Time Limit: 1000MS Memory limit: 65536K 题目描述 小明在学习了数据结构之后,突然想起了以前没有解决的算术表达式转化成后缀式的问题,今天他想解决一下. 因为有了数据结构的基础小明很快就解出了这个问题,但是他突然想到怎么求出算术表达式的前缀式和中缀式呢?小明很困惑.聪明的你帮他解决吧. 输入 输入一算术表达式,以\'#\'字符作为结束标志.(数据保证无空格,只有一组输入) 输出 输出该表达式转换所得到的前缀式 中缀式 后缀式.分三行输出,顺序

使用栈实现解析算术表达式

目的 1. 使用栈将中缀表达式转换成后缀表达式 2. 使用后缀表达式求算术值 注意: 因为是简单实践,所以代码逻辑已经简化,比如只能对个位数的加减乘除进行解析.没有设异常处理等 一:需要实现一个栈 这个没什么好说的,只是一个结构很简单的栈 1 public class Stack { 2 3 private int maxSize; 4 private int top; 5 private Object[] stackArr; 6 7 public Stack(int maxSize) { 8

二、数据结构之栈、队列、循环队列

二.数据结构之栈.队列.循环队列 顺序栈 Stack.h 结构类型,函数声明: #ifndef _STACK_H_ #define _STACK_H_ typedef int SElementType; ///顺序栈 #define STACK_INIT_SIZE 20 #define STACK_INCREMENT 10 typedef struct { SElementType * base; SElementType * top; int stackSize;///当前栈的大小 }SqSt

数据结构(7)----栈与队列之栈的应用四则运算表达式求值

栈与队列之栈的应用四则运算表达式求值 栈在四则运算表达式求值的应用为逆波兰表达式(后缀表达式) 普通算式(中缀表达式):9 + (3 - 1) * 3 + 10 / 2     ---(1) 逆波兰表达式(后缀表达式):9 3 1 - 3 * + 10 2 /         ---(2) 1:逆波兰表达式的计算规则 从左到右遍历表达式的每个数字和符号,遇到数字就进栈,遇到符号,就将处于栈顶的两个数字出栈,进行运算,再把运算结果进栈,一直到最终获得结果.接下来我们以(2)式为例:

【转载】浅谈算法和数据结构: 一 栈和队列

作者:yangecnu(yangecnu's Blog on 博客园) 出处:http://www.cnblogs.com/yangecnu/ 最近晚上在家里看Algorithms,4th Edition,我买的英文版,觉得这本书写的比较浅显易懂,而且“图码并茂”,趁着这次机会打算好好学习做做笔记,这样也会印象深刻,这也是写这一系列文章的原因.另外普林斯顿大学在Coursera 上也有这本书同步的公开课,还有另外一门算法分析课,这门课程的作者也是这本书的作者,两门课都挺不错的. 计算机程序离不开

浅谈算法和数据结构: 一 栈和队列

最近晚上在家里看Algorithems,4th Edition,我买的英文版,觉得这本书写的比较浅显易懂,而且"图码并茂",趁着这次机会打算好好学习做做笔记,这样也会印象深刻,这也是写这一系列文章的原因.另外普林斯顿大学在Coursera 上也有这本书同步的公开课,还有另外一门算法分析课,这门课程的作者也是这本书的作者,两门课都挺不错的. 计算机程序离不开算法和数据结构,本文简单介绍栈(Stack)和队列(Queue)的实现,.NET中与之相关的数据结构,典型应用等,希望能加深自己对这

数据结构之栈和队列

数据结构学习继续向前推进,之前对线性表进行了学习,现在我们进入栈和队列的学习.同样我们先学习一些基本概念以及堆栈的ADT. 栈和队列是两种中重要的线性结构.从数据结构角度看,栈和队列也是线性表,只不过是受限的线性表.因此可以称为限定性数据结构.但从数据类型来看,他们是和线性表大不相同的两类重要的抽象数据类型. 栈:(stack)是限定仅在表尾进行相应插入和删除操作的线性表.因此,对栈来说,表尾有其特殊含义,称为栈顶,表头称为栈底,不含元素的空表称为空栈.栈一个重要特性就是后进先出.OK,我们来看

数据结构之栈与队列

数据结构的有一个重要结构栈,栈这种数据结构就是满足先进后出的这种规则的数据结构就是栈,引用<大话数据结构>中的一个形象例子就是,子弹的弹夹,最先压入弹夹的子弹最后一个出弹夹,正好往一个栈里添加一个元素叫压栈.入栈,从栈里出来一个元素叫弹栈,出栈.指示器就叫栈帧. 栈图 现在就贴上代码: 栈的几个基本操作: #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct node{