黑龙江大学《数据结构与算法》实验六 表达式求值问题

已于 2022-10-17 17:58:43 修改
阅读量496 收藏 5
点赞数 4
文章标签： c++ 算法
于 2022-10-12 20:23:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swimmingmm/article/details/127289714
版权

 一般的运算式都是中缀表达式，顺序扫描中缀表达式，当读到数字时，直接将其送至输出队列中；当读到运算符时，将 运算符栈中所有优先级高于或等于当前运算符的运算符弹出，送至输出队列中，再将当前运 算符入栈；当读入左括号时，将其入运算符栈；当读到右括号时，将运算符符栈中从栈顶到 靠近栈顶的第一个左括号(“伪栈底”）之间的所有运算符全部依次弹出，送至输出队列中， 再删除栈中的左括号。 为了简化算法，可认为扫描到的任何运算符，其优先级都比栈顶的左括号优先级高。为 了方便边界条件（栈空）判断，提高算法运行效率，在扫描中缀表达式之前，在空栈中预先 压入一个‘#’字符作为栈底元素，另外，在中缀表达式的最后增加一个‘#’字符作为中缀 表达式的结束标志，当扫描到结束符‘#’时，将栈中从栈顶到‘#’之间的所有运算符全部 依次弹出，送至输出队列中，再删除栈中的‘#’，并结束算法。 除了显示算法的运行结果外，最好能在算法运行过程中演示运算符栈和存放后缀表达式 的队列的变化情况。如，若输入的中缀表达式字符串：1+2*（3-1+2）-3#，就会得到后缀表 达式：1231-2+*+3-，在算法运行过程中，运算符栈和存放后缀表达式的队列变化过程如表 1 所示。

void Infixtosuffix(string expression)
{
    gotoxy(25,10);
    cout<<"输出将中缀转换成后缀后得到的表达式：";
    string s=expression;
    char fu[100];
    y.clear();
    int top1=-1;
    top2=-1;
    top1++;
    fu[top1]='#';
    for(int i=0;i<s.size()-1;i++)
    {
        if(s[i]>='0'&&s[i]<='9')
        {
            top2++;
            y[top2]=s[i];
        }
        else
        {
            if(s[i]=='+')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='+'||fu[top1]=='-'||fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='-')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='+'||fu[top1]=='-'||fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='*')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='/')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='(')
            {
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]==')')
            {
                if(top1>=1)
                {
                    while(fu[top1]!='(')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                    top1--;
                }
            }
        }
    }
    while(top1!=0)
    {
        top2++;
        y[top2]=fu[top1];
        top1--;
    }
    for(int i=0;i<=top2;i++)cout<<y[i];
    gotoxy(25,11);
    cout<<"按任意键返回菜单：";
    getch();
    system("cls");
    menu(expression);
}

后缀表达式的计算

利用栈（操作数和运算结果栈）计算后缀表达式。顺序扫描后缀表达式，当读到数字时， 将其送至栈中；当读到运算符 θ 时，将栈顶字符弹出，将其转换成对应的数值并赋给变量 y， 再将次栈顶字符弹出，将其转换成对应的数值，并赋给变量 x，之后计算 xθy，将运算结果转 换成对应的数字字符送入栈中。 本算法可以对任意输入的后缀表达式进行计算，也可以以前一个中缀表达式到后缀表达 式转换算法的输出为输入，计算该后缀表达式。 除了显示算法的运行结果外，最好能在算法运行过程中演示（操作数和运算结果）栈的 变化情况。以输入的后缀表达式为 1231-2+*+3-的情况为例，在算法运行过程中，操作数及运 算结果栈变化过程如表 2 所示。

void Calculationsuffixexpression()
{
    if(top2==-1)
    {
        gotoxy(30,10);
        cout<<"中缀表达式还未转换成后缀表达式"<<endl;
    }
    else{
    int cal[100];//建立个栈用来存数计算后缀表达式
    int top=-1;//表示栈顶
    for(int i=0;i<=top2;i++)
    {
        if(y[i]>='0'&&y[i]<='9')
        {
            top++;
            cal[top]=y[i]-'0';
        }
        else
        {
            int num=cal[top];
            top--;
            if(y[i]=='+')cal[top]=cal[top]+num;
            else if(y[i]=='-')cal[top]=cal[top]-num;
            else if(y[i]=='*')cal[top]=cal[top]*num;
            else if(y[i]=='/'&&num!=0)cal[top]=cal[top]/num;
        }
    }
    gotoxy(30,10);
    cout<<"输出计算结果：";
    cout<<cal[top];
    }
    gotoxy(30,11);
    cout<<"按任意键返回菜单:";
    getch();
    system("cls");
    menu(ss);
}

中缀的计算比较抽象，只可意会不可言传，这里就不多说了，怕误了大家。

这次实验有两个项目，这里是关于表达式求值的，我的实验偏向于意识流，代码长只可意会不可言传，本人又菜写的bug又多，发出来仅供参考，能自己写最好。

#include <iostream>
#include<bits/stdc++.h>
#include<windows.h>
#include<conio.h>
using namespace std;

string ss;//全局变量用于输入中缀表达式
string y;//全局变量用于储存后缀表达式
int top2=-1;//全局变量用于记录后缀表达式的长度
void gotoxy(int x, int y);//更新光标位置，用于打印菜单
void sscanf();//输入表达式
void Interface();//打印菜单
void Infixtosuffix(string expression);//将中缀表达式转换成后缀表达式
void Calculationsuffixexpression();//计算后缀表达式
void Computeinfixexpression();//计算中缀表达式
void menu();//菜单选择


void gotoxy(int x, int y)
{
    // 更新光标位置
    COORD pos;
    HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);// 获取标准输出设备句柄
    pos.X = x;
    pos.Y = y;
    SetConsoleCursorPosition(hOutput, pos);//两个参数分别是指定哪个窗体，具体位置
    // 隐藏光标
    CONSOLE_CURSOR_INFO cursor;
    cursor.bVisible = FALSE;
    cursor.dwSize = sizeof(cursor);
    SetConsoleCursorInfo(hOutput, &cursor);
}

void Interface()//打印菜单
{
    gotoxy(30,5);
    cout<<"------------------------------------------------------";
    gotoxy(50,6);
    cout<<"表达式求值";
    gotoxy(30,7);
    cout<<"1. 中缀表达式到后缀表达式的转换";
    gotoxy(30,8);
    cout<<"2. 后缀表达式的计算";
    gotoxy(30,9);
    cout<<"3. 中缀表达式的计算";
    gotoxy(30,10);
    cout<<"4. 退出";
    gotoxy(30,11);
    cout<<"5. 重新输入算数表达式";
    gotoxy(30,12);
    cout<<"-------------------------------------------------------";
}

void menu(string expression)
{
    Interface();
    gotoxy(30,13);
    cout<<"输入选择：";
    int choice;
    cin>>choice;
    system("cls");
    switch(choice)
    {
    case 1:
        {
            Infixtosuffix(expression);
            break;
        }
    case 2:
        {
            Calculationsuffixexpression();
            break;
        }
    case 3:
        {
            Computeinfixexpression();
            break;
        }
    case 4:
        {
            gotoxy(50,10);
            cout<<"运算结束"<<endl;
            break;
        }
    case 5:
        {
            sscanf();
            break;
        }
    }
}


void Infixtosuffix(string expression)
{
    gotoxy(25,10);
    cout<<"输出将中缀转换成后缀后得到的表达式：";
    string s=expression;
    char fu[100];
    y.clear();
    int top1=-1;
    top2=-1;
    top1++;
    fu[top1]='#';
    for(int i=0;i<s.size()-1;i++)
    {
        if(s[i]>='0'&&s[i]<='9')
        {
            top2++;
            y[top2]=s[i];
        }
        else
        {
            if(s[i]=='+')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='+'||fu[top1]=='-'||fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='-')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='+'||fu[top1]=='-'||fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='*')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='/')
            {
                if(top1>=1)
                {
                    while(fu[top1]=='*'||fu[top1]=='/'||fu[top1]==')')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                }
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]=='(')
            {
                top1++;
                fu[top1]=s[i];
            }
            else if(s[i]==')')
            {
                if(top1>=1)
                {
                    while(fu[top1]!='(')
                    {
                        top2++;
                        y[top2]=fu[top1];
                        top1--;
                    }
                    top1--;
                }
            }
        }
    }
    while(top1!=0)
    {
        top2++;
        y[top2]=fu[top1];
        top1--;
    }
    for(int i=0;i<=top2;i++)cout<<y[i];
    gotoxy(25,11);
    cout<<"按任意键返回菜单：";
    getch();
    system("cls");
    menu(expression);
}

void Calculationsuffixexpression()
{
    if(top2==-1)
    {
        gotoxy(30,10);
        cout<<"中缀表达式还未转换成后缀表达式"<<endl;
    }
    else{
    int cal[100];//建立个栈用来存数计算后缀表达式
    int top=-1;//表示栈顶
    for(int i=0;i<=top2;i++)
    {
        if(y[i]>='0'&&y[i]<='9')
        {
            top++;
            cal[top]=y[i]-'0';
        }
        else
        {
            int num=cal[top];
            top--;
            if(y[i]=='+')cal[top]=cal[top]+num;
            else if(y[i]=='-')cal[top]=cal[top]-num;
            else if(y[i]=='*')cal[top]=cal[top]*num;
            else if(y[i]=='/'&&num!=0)cal[top]=cal[top]/num;
        }
    }
    gotoxy(30,10);
    cout<<"输出计算结果：";
    cout<<cal[top];
    }
    gotoxy(30,11);
    cout<<"按任意键返回菜单:";
    getch();
    system("cls");
    menu(ss);
}

void Computeinfixexpression()
{
    int num[100];//存数字的栈
    char fu[100];//存符号的栈
    int t1=-1;//数字栈的栈顶初始为-1
    int t2=-1;//符号栈的栈顶初始为-1
    t2++;
    fu[t2]='#';
    for(int i=0;i<ss.size();i++)
    {
        if(ss[i]>='0'&&ss[i]<='9')
        {
            t1++;
            num[t1]=ss[i]-'0';
        }
        else
        {
            if(ss[i]=='+'||ss[i]=='-')
            {
                if(t2>0)
                {
                    if(fu[t2]=='+')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]+=k;
                        t2--;
                    }
                    else if(fu[t2]=='-')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]-=k;
                        t2--;
                    }
                    else if(fu[t2]=='*')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]*=k;
                        t2--;
                    }
                    else if(fu[t2]=='/'&&num[t1]!=0)//除法可能需要特判一下0，但是只要不闲的没事输入0应该就没有问题了（解决不了问题就解决提出问题的人）
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]/=k;
                        t2--;
                    }
                }
                t2++;
                fu[t2]=ss[i];
            }
            else if(ss[i]=='*'||ss[i]=='/')
            {
                if(t2>0)
                {
                    if(fu[t2]=='*')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]*=k;
                        t2--;
                    }
                    else if(fu[t2]=='/'&&num[t1]!=0)//除法可能需要特判一下0，但是只要不闲的没事输入0应该就没有问题了（解决不了问题就解决提出问题的人）
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]/=k;
                        t2--;
                    }
                }
                t2++;
                fu[t2]=ss[i];
            }
            else if(ss[i]=='(')
            {
                t2++;
                fu[t2]=ss[i];
            }
            else if(ss[i]==')')
            {
                while(fu[t2]!='(')
                {
                    if(t2>1)
                {
                    if(fu[t2]=='+')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]+=k;
                        t2--;
                    }
                    else if(fu[t2]=='-')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]-=k;
                        t2--;
                    }
                    else if(fu[t2]=='*')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]*=k;
                        t2--;
                    }
                    else if(fu[t2]=='/'&&num[t1]!=0)
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]/=k;
                        t2--;
                    }
                }
                }
                t2--;
                if(t2>1)
                {
                    if(fu[t2]=='+')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]+=k;
                        t2--;
                    }
                    else if(fu[t2]=='-')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]-=k;
                        t2--;
                    }
                    else if(fu[t2]=='*')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]*=k;
                        t2--;
                    }
                    else if(fu[t2]=='/'&&num[t1]!=0)
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]/=k;
                        t2--;
                    }
                }
            }
            else if(ss[i]=='#')
            {
                while(fu[t2]!='#')
                {
                    if(fu[t2]=='+')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]+=k;
                        t2--;
                    }
                    else if(fu[t2]=='-')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]-=k;
                        t2--;
                    }
                    else if(fu[t2]=='*')
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]*=k;
                        t2--;
                    }
                    else if(fu[t2]=='/'&&num[t1]!=0)
                    {
                        int k=num[t1];
                        t1--;
                        num[t1]/=k;
                        t2--;
                    }
                }
            }
        }
    }
    gotoxy(30,10);
    cout<<"输出计算结果：";
    cout<<num[0];
    gotoxy(30,11);
    cout<<"按任意键返回菜单：";
    getch();
    system("cls");
    menu(ss);
}

void sscanf()//输入算数表达式
{
    ss.clear();
    gotoxy(42,13);
    cout<<"输入算数表达式:";
    cin>>ss;
    system("cls");
    menu(ss);
}

int main()
{
    system("color b");//(整活)给字体换个颜色
    sscanf();
    return 0;
}

 

swimming的奇妙冒险
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构课程实验二：运用栈实现表达式求值
m0_64198455的博客
12-22 4052
运用栈实现表达式求值
黑大软件学院数据结构实验.rar
03-24
黑大软件学院数据结构实验.rar
数据结构与算法--表达式求值
Cruies_95633的博客
04-24 2046
算术表达式由操作、运算符组成，在计算机中进行算术表达式的计算是通过堆栈来实现的。通常两个栈就能实现表达式求值。
Vijos数据结构基础C++实验整理（六）——计算表达式（栈的应用）
SunnySantino的博客
01-15 1272
实验内容 创建栈类，采用数组描述； 计算数学表达式的值。 输入数学表达式，输出表达式的计算结果。数学表达式由单个数字和运算符+、-、、/、(、)构成，例如 2+3(4+5)-6/4。假定表达式输入格式合法。 样例： 输入： 3 1+6/17+214+9/1+209+9+7/(95)-16-08-7-92+6-(0-5-28-7-95(6-5526-2-7-5+67+69-100+30+2/1-6/6+5)) 0-4-1/6*(1-(6/7)-4+6+2+61)-17+2-82+0-(4+6-61+(3-86
黑龙江大学《数据结构与算法》实验五 树的应用
swimmingmm的博客
10-07 629
实验五 树的应用（2 学时） 一、实验目的 1、掌握二叉树的各种存储结构的特点及适用范围。2、掌握建立二叉树的方法。（包括顺序存储、二叉链表存储） 3、熟练掌握二叉树的前序、中序、后序遍历的递归及非递归算法；3、以二叉链表作存储结构，编写非递归的前序、中序、后序遍历算法。（3）题目 3 可以考虑利用栈来实现，难点在于后序遍历的非递归算法的实现（何时入栈， 如何标识何时出栈）。只完成前两个题目最多得 2 分，高质量完成 3 个题目给 3 分，未按时 完成或算法的时间与空间复杂度过高会酌情扣分。
实验五实现表达式求值(stack实现)
执念斩长河
03-27 2781
本博文源于严蔚敏老师的《数据结构》，今天就来聊聊如何实现一位数运算数加法和多位数运算符加法。本代码完全对书中的代码再现，没有其他的过多的想法，包括多位数运算法加法也只是对原有内容基础上修改罢了。如果读者对此非常感兴趣，也可以收藏进行深度学习一波。
恋上数据结构与算法课件.rar
11-23
栈是一种后进先出（LIFO）的数据结构，常用于实现函数调用、表达式求值等。栈的操作主要有压栈（将元素放入栈顶）和弹栈（移除栈顶元素）。栈在编程中的应用广泛，如浏览器的历史记录、递归等。 队列是先进先出...
数据结构与算法.rar
07-22
在这个压缩包“数据结构与算法.rar”中，我们很可能是找到了一系列关于这个主题的教学材料，特别是针对黑龙江大学金英老师的课程。这份资源可能包含了实验指导、实验报告和其他辅助学习资料，对于学习者来说是一份...
黑龙江大学《算法设计与分析》实验源码及实验报告
05-06
实验一：分治算法的设计与实现（求最大子段和、找众数和重数） 实验二：动态规划算法的设计与...实验报告内有算法思想简述、数据结构、时间空间复杂度、测试用例和实验结果截图。 每个实验报告内有实验源码和实验总结。
数据结构与算法课件.zip
最新发布
04-02
数据结构与算法是计算机科学中的核心课程，它们是构建高效软件和系统的基础。在这个名为“数据结构与算法课件.zip”的压缩包中，包含了关于这些关键主题的详细讲解材料。让我们逐一探讨这些重要的知识点。 首先，...
数据结构与算法实验6——栈
whereMyHairIs的博客
11-14 1153
1.实验内容 创建栈类，采用数组描述；计算数学表达式的值。 输入数学表达式，输出表达式的计算结果。数学表达式由单个数字和运算符“+”、“-”、“*”、“/”、“(”、“)”构成，例如 2+3*(4+5)–6/4。 输入输出格式： 输入： 第一行一个整数n(1<=n<=100)，代表表达式的个数。 接下来n行，每行一个表达式，保证表达式内的数字为单个整数，表达式内各运算符和数字间没有空格，且表达式的长度不超过2000。 输出： 每行表达式输出一个浮点数，要求保留两位小数，保证输.
实验四 表达式计算（第7周）
我要吃木耳的博客
10-20 302
实验目的： 熟练掌握栈和队列的存储结构设计及基本操作的实现；学会分析实际问题中具有栈特点的数据结构；了解表达式的前缀、中缀、后缀等计算机内表示形式。 实验内容与要求： 按常规形式输入算术表达式（例如：输入2*(6-4)+8/4），要求能够： ⑴生成表达式的前缀、后缀表示，并输出； ⑵基于表达式的前、中、后缀表示，对该表达式求值； ⑶编写一个主程序对表达式求值函数进行测试。 进阶要求：表达式中数据为多位数 进阶的还没写，晚点再说把 #include<iostrea...
数据结构 实验2——表达式求值
热门推荐
m0_57587757的博客
10-09 1万+
一、实验名称：表达式求值 二、实验学时：6学时 三、实验目的 1.理解栈的结构特点和基本操作特性； 2.掌握利用栈实现表达式求值算法。 四、实验内容(步骤) 输入一个算术表达式(以“=”结束)，求其值。要求表达式以“=”结束，操作数为多位实数，对错误表达式要进行检测。 1.设置两个栈：optr算符栈和opnd操作数栈。初始置opnd为空栈；起始符“=”为optr的栈底元素； 2.自左向右扫描表达式中的每个字符c： 1)若c为操作数，则进opnd栈； 2)若c为算符，则让optr栈的栈顶元
光标移动函数
不知博者的博客
05-13 2305
光标移动函数： COORD: 关键字 原函数typedef struct _COORD {SHORT X;SHORT Y;} COORD, *PCOORD; HANDLE:关键字 定义句柄 GetStdHandle(STD_OUTPUT_HANDLE):函数获得标准输入输出的句柄 STD_OUTPUT_HANDLE:宏 代表标准输出 可看作显示器 SetConsoleCursorPositi
数据结构与算法 - 计算表达式
qq_45917176的博客
06-30 2642
数据结构--数据结构与算法 - 计算表达式
数据结构—表达式求值
weixin_60145573的博客
07-12 7867
要解决的问题 任何一个表达式都是由操作数（operand），运算符（operator），和界限符（delimiter）组成的，求表达式主要的问题有：1：表达式是否合理；2；符号的优先级关系；3；多位数处理4；正确求值； 1.算法基本思想描述： 处理该题型，我运用了栈的知识，首先初建OPTR（运算符）和OPND（数字）两个栈，后输入字符串以‘=’结束，对每个字符进行分析，若ch为数字，则压入OPND栈，若ch为运算符号，先判断OPTR栈头和ch的优先级关系，再做不...
数据结构---栈的应用--简单表达式求值问题
qq_44950065的博客
08-18 4309
数据结构—栈的应用–简单表达式求值问题 问题描述 用户输入一个包含+、-、*、/、正整数和圆括号的合法算数表达式，计算该表达式的结果。 设计思路 计算简单表达式的值，其实主要是要处理运算符优先级不同以及可能有括号，从而造成运算顺序不一定按照从左往右顺序计算。 因此，需要对算数表达式符号的顺序进行调整，使之能够以一种计算机能够直接方便理解的方式来顺序地计算。 栈的主要特点是：先入后出，后入先出。因此可以利用这一特点将栈作为一种存放临时数据的容器，后存入的数据先处理。从而来调整算术表达式的各种字符之间的顺序，方
用栈数据结构对算数表达式求值的思想
bc_33的博客
10-12 2092
问题描述 表达式求值是程序设计语言编译中的一个基本问题，是栈应用的一个典型例子。对于一个简单的算数表达式，假如它的操作数是整型常数，运算符有加减乘除四种运算符，界限符有左右括号、表达式起始符和表达式结束符（#）。那么，它应遵循算数四则运算的规则是：从左到右，先括号内，后括号外，先乘除后加减。 算法分析 要对一个算数表达式求值，首先要了解算符（运算符和界限符）间的优先关系，即算数表达式的计算顺序，从而决定如何对表达式进行操作。对算数表达式进行扫描，任意两个相继...
《数据结构与算法》实验：线性结构及其应用——算术表达式求值
Zhuoning Guo's Blog
02-02 2860
《数据结构与算法》实验和课程Github资源 《数据结构与算法》实验：线性结构及其应用——算术表达式求值 《数据结构与算法》实验：树型结构的建立与遍历 《数据结构与算法》实验：图结构的建立与搜索 《数据结构与算法》实验：查找结构的实验比较——二叉查找树BST & 二分（折半）查找 《数据结构与算法》实验：排序算法实验比较——选择排序 & 堆排序 《数据结...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值