表达式转换-中缀转后缀表达式后计算-数据结构与算法

简介: 表达式转换-中缀转后缀表达式后计算-数据结构与算法

问题


一个计算中缀表达式的算法题


40分,其余六个测试点都显示"read(ASCII 13)"

我的代码现在一直只能过第1、6、7、8这四个测试集,

查看测试集显示错误信息:


“Wrong Answer.wrong answer On line 1 column 25, read (ASCII 13), expected +.”

题目链接:表达式转换-洛谷


我查了(ASCII 13)是回车键,但是我又能过四个测试集,为什么输出会有回车键的问题呢?


谁能救救我啊?万分感谢!


下面是我的代码(可能有点乱,抱歉):

/*long long
1)输入数字是单个数字
2)输入没有负数 */
#include<iostream>
#include<cstdio>
#include<stack>
using namespace std;
const int max0 = 500;
stack<char> s;  //计算后缀表达式用 
long long get_num();      //从栈中返回一个整型数字 
bool compare_sign(char big, char small);  //比较两个(四则运算符)运算符的优先级 
void change(char str[]);      //给新转化出来的后缀表达式 操作数 加分隔符'.'
void out_bds(char str[], int i, stack<char> ss);//输出中间产物表达式
int main() {
  char a[max0]{};   //后缀表达式 
  int ac(0);    //迭代a
  stack<char> sign;  //符号栈
  char m[max0]{};   //待处理的中缀表达式
  char ch(0);
  for(int i = 0; i < max0; ++i){
  ch = getchar();
  if(ch == '\n') break;
  m[i] = ch; } 
  //--------------------一、中缀表达式转后缀表达式 
  for(int i = 0; i < max0 && m[i] != '\0'; i++) {  //读取中缀表达式并开始转换 
  if('0' <= m[i] && m[i] <= '9') {    //遇到操作数,直接加入后缀表达式 
    a[ac++] = m[i]; }
  else if(m[i] != '(' && m[i] != ')') {  
    while(!sign.empty() && compare_sign(sign.top(), m[i])) { 
    a[ac++] = sign.top();     //遇到运算符,出栈优先级不小于它的运算符加入表达式,直到栈空或遇到'('
    sign.pop(); }
    sign.push(m[i]); }        //然后自己入栈 
  else if(m[i] == '(') {
    sign.push(m[i]); }
  else if(m[i] == ')') {        //遇到')',出栈加入表达式直到'(' 
    while(sign.top() != '(') {
    a[ac++] = sign.top();
    sign.pop(); }
    sign.pop(); }}
  while(!sign.empty()) {  //出栈所有剩余运算符 
  a[ac++] = sign.top();
  sign.pop(); }
  change(a);
  out_bds(a, 0, s);
  //--------------------二、计算后缀表达式 
  char t(0); ac = 0;  
  while(true) {
  t = a[ac++];      //入栈 
  if(t == '@') {s.pop();break;}
  s.push(t);
  if(t == '+' || t == '-' || t == '*' || t == '/' || t == '^') {  //见运算符
    s.pop();    //出栈运算符
    long long d(0), b(0); //出栈两个数字为int型
    s.pop(); d = get_num();
    s.pop(); b = get_num();
    long long result(1);  //计算
    if(t == '+') result = b + d;
    else if(t == '-') result = b - d;
    else if(t == '*') result = b * d;
    else if(t == '/') result = b / d;
    else if(t == '^') {
    for(int i = 0; i < d; ++i)
      result *= b; }
    if(result < 0) {s.push('0'); result = -result;}
    stack<char> c;    //结果转为char型再入栈
    if(result == 0) {s.push('0');}
    while(result != 0) {
    c.push((char)(result % 10 + '0'));
    result /= 10; }
    while(!c.empty()) {
    s.push(c.top());
    c.pop(); }
    s.push('.');
    out_bds(a, ac, s); }}
  return 0; }
//----------------------------------------
//只考虑了表达式转换过程中可能发生的优先级比较 
bool compare_sign(char big, char small) {
  if(big == '+' || big == '-') {
  if(small == '+' || small == '-') return true; }
  else if(big == '*' || big == '/' || big == '^') {
  if(small != '(' && small != '^') return true; }
  return false; }
//----------------------------------------
//从char型栈中读取出一个int型操作数 
long long get_num() {
  long long sum(0);
  char t(0);
  for(long long i = 1; s.top() != '.'; i *= 10) {  //i也是必须开long long的 
  t = s.top();
  sum += (long long)(s.top() - '0') * i;
  s.pop();
  if(s.empty()) break; }
  if(t == '0') sum = -sum;
  return sum; }
//----------------------------------------
//从char型栈中读取出一个int型操作数;out_bds()的配套 
long long get_num(stack<char> &ss) {
  long long sum(0);
  char t(0);
  for(long long i = 1; ss.top() != '.'; i *= 10) 
  { t = ss.top();
  sum += (long long)(ss.top() - '0') * i;
  ss.pop();
  if(ss.empty()) break; }
  if(t == '0') sum = -sum;
  return sum; }
//----------------------------------------
//给新转化出来的后缀表达式 操作数 加分隔符'.'
void change(char str[]) {
  char t[max0]{};
  int tc(0);
  for(int i = 0; str[i] != '\0'; i++) {
  if('0' <= str[i] && str[i] <= '9') {
    t[tc++] = str[i];
    t[tc++] = '.'; }
  else t[tc++] = str[i]; }
  for(int i = 0; t[i] != '\0'; i++) 
  str[i] = t[i];
  str[tc] = '@'; }  //表达式结束符
//----------------------------------------
//输出中间产物表达式,从str[i]开始;参数建立了一个副本栈,不担心原s改变 
void out_bds(char str[], int i, stack<char> ss) {
  stack<long long> t;   //中转站 
  while(ss.empty() == 0) {
  if(ss.top() == '.')
    ss.pop();
  t.push(get_num(ss)); }
  while(t.empty() == 0) {
  cout << t.top() << " ";
  t.pop(); }
  for( ; str[i] != '\0'; i++) {
  if(str[i] != '.' && str[i] != '@') 
    cout << str[i] << " "; }
  cout << endl; } 
/*
测试集
8-(3+2*6)/5+4
9+(9^8+(9^8+(9^8+(9^8))))
*/

程序运行:


image.png

经验总结


注意创建的数组大小,题目说输入字符串长度不超过100,但是表达式计算过程中的中间结果是可能超过100的。


注意不要变量名冲突。


仔细审题,有些坑很细,如:计算过程总数字不超过231,但是可能等于,那int类型就不够了。

如果重载了函数,修改其中一个时可能其它的也需要修改

输出格式其实挺烦的,有时题目不会说很清楚,甚至就必须有行末空格。

相关文章
|
1月前
|
存储 分布式计算 算法
大数据-106 Spark Graph X 计算学习 案例:1图的基本计算、2连通图算法、3寻找相同的用户
大数据-106 Spark Graph X 计算学习 案例:1图的基本计算、2连通图算法、3寻找相同的用户
60 0
|
1月前
|
算法
数据结构与算法二:栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式
这篇文章讲解了栈的基本概念及其应用,并详细介绍了中缀表达式转换为后缀表达式的算法和实现步骤。
44 3
|
1月前
|
JSON 算法 数据可视化
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算(目标检测)
这篇文章是关于如何通过算法接口返回的目标检测结果来计算性能指标的笔记。它涵盖了任务描述、指标分析(包括TP、FP、FN、TN、精准率和召回率),接口处理,数据集处理,以及如何使用实用工具进行文件操作和数据可视化。文章还提供了一些Python代码示例,用于处理图像文件、转换数据格式以及计算目标检测的性能指标。
57 0
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算(目标检测)
|
1月前
|
存储 算法 Java
数据结构与算法学习八:前缀(波兰)表达式、中缀表达式、后缀(逆波兰)表达式的学习,中缀转后缀的两个方法,逆波兰计算器的实现
前缀(波兰)表达式、中缀表达式和后缀(逆波兰)表达式的基本概念、计算机求值方法,以及如何将中缀表达式转换为后缀表达式,并提供了相应的Java代码实现和测试结果。
44 0
数据结构与算法学习八:前缀(波兰)表达式、中缀表达式、后缀(逆波兰)表达式的学习,中缀转后缀的两个方法,逆波兰计算器的实现
|
1月前
|
算法 Java C语言
【数据结构】后缀(逆波兰)表达式的计算以及中缀转后缀的方法
【数据结构】后缀(逆波兰)表达式的计算以及中缀转后缀的方法
35 0
|
2月前
|
算法 C++
如何精确计算出一个算法的CPU运行时间?
如何精确计算出一个算法的CPU运行时间?
|
2月前
|
算法 数据可视化 数据安全/隐私保护
基于LK光流提取算法的图像序列晃动程度计算matlab仿真
该算法基于Lucas-Kanade光流方法,用于计算图像序列的晃动程度。通过计算相邻帧间的光流场并定义晃动程度指标(如RMS),可量化图像晃动。此版本适用于Matlab 2022a,提供详细中文注释与操作视频。完整代码无水印。
|
3月前
|
算法 Go Python
[算法]计算斐波拉契数列
[算法]计算斐波拉契数列
|
3月前
|
算法
计算空间物体包围球的两种算法实现
计算空间物体包围球的两种算法实现
48 0
|
5月前
|
机器学习/深度学习 算法
**反向传播算法**在多层神经网络训练中至关重要,它包括**前向传播**、**计算损失**、**反向传播误差**和**权重更新**。
【6月更文挑战第28天】**反向传播算法**在多层神经网络训练中至关重要,它包括**前向传播**、**计算损失**、**反向传播误差**和**权重更新**。数据从输入层流经隐藏层到输出层,计算预测值。接着,比较预测与真实值计算损失。然后,从输出层开始,利用链式法则反向计算误差和梯度,更新权重以减小损失。此过程迭代进行,直到损失收敛或达到训练次数,优化模型性能。反向传播实现了自动微分,使模型能适应训练数据并泛化到新数据。
69 2

热门文章

最新文章