c语言中缀表达式转化后缀表达式优化final

最新推荐文章于 2022-08-30 00:26:42 发布
最新推荐文章于 2022-08-30 00:26:42 发布
阅读量164 收藏
点赞数 1
分类专栏： 数据结构 文章标签： c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43919162/article/details/84976334
版权
本文详细介绍了如何使用C语言将中缀表达式转换为后缀表达式（也称为逆波兰表示法），并讨论了算法优化的最终版本。通过对表达式的操作，利用栈数据结构，实现了括号匹配和运算符优先级的处理，提高了计算效率。
摘要由CSDN通过智能技术生成 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
//附加功能:
//附加功能1:附加了%取余数的操作！！！
//附加功能2:附加了求对数ln的功能！！！
//附加功能3:附加了取绝对值操作！！！
//别忘了写程序之前写个伪代码分析一下！！！
//别靠空想！！！及其浪费时间！！！多谢谢伪代码分析一下！！！
//后缀表示法计算时候的思路！！！先把元素推到栈中，每碰到一个
char stack[50];//用于存储outpush中的元素
char output[50];//用于存储中缀表达式结果
char nouse[50];//用于存储’）’这个不在中缀表达式中出现的元素
int flag=0;//标志量，标定限制状态
char sz[50];//存储中缀表达式中的数据
char laji[50];//垃圾桶，存取无用的字符元素
int szz[50];//存储中缀表达式中的数字，以及中缀表达式中的符号，在szz中分别用80001，80002，80003，80004，80005表示   ’+’    ’-‘    ‘*’    ‘/’   ’%’
int jieguo[50];//中缀表达式求值中的堆栈
int wuyong[50];//垃圾桶，用于存储栈操作中无用的数字
int laji1[50];//垃圾桶


int ce[3]= {1,2,-9999};
int ce1[3]= {7,8,-9999};
void push(char stack3[],char push1);//压栈操作
int change(char aa);//将输入的字符串的每个字母依次压栈，求中缀表达式
void pop(char stack1[],char stack2[]);//从第一个栈弹出给第二个,必须堆栈中用东西才可以弹出
void push1(int stack31[],int push11);//在计算中缀表达式中用于压栈
void pop1(int stack11[],int stack21[]);//在中缀表达式求值时用于弹栈
void  WritetoFile(char wenjian[]);     //用于将中缀表达式写入文件
void  ReadfromFile(char wenjian1[]);   //用于将中缀表达式从文件中读出
void pop(char stack1[],char stack2[])
{
    int i;
    int j;
    char tmppop;
    for(i=0; i<50; i++)
    {
        if(stack1[i]=='\0')
        {
            tmppop=stack1[0];
            for(j=0; j<i; j++)
            {
                stack1[j]=stack1[j+1];
            }
            break;
        }
    }
    push(stack2,tmppop);
}
void push(char stack3[],char push1)
{
    int i;
    int j;
    for(i=0; i<50; i++)
    {
        if(stack3[i]=='\0')//在函数里用函数里的变量！！！一定注意！！！小心！！！
        {
            if(i==0)
            {
                stack3[0]=push1;
            }
            else
            {
                for(j=0; j<=i; j++)
                {
                    stack3[i-j+1]=stack3[i-j];
                }
                stack3[0]=push1;
                break;
            }
        }
    }
}
void push1(int stack31[],int push11)
{
    int i;
    int j;
    for(i=0; i<50; i++)
    {
        if(stack31[i]<=-9999)//在函数里用函数里的变量！！！一定注意！！！小心！！！
        {
            if(i==0)
            {
                stack31[0]=push11;
            }
            else
            {
                for(j=0; j<=i; j++)
                {
                    stack31[i-j+1]=stack31[i-j];
                }
                stack31[0]=push11;
                break;
            }
        }
    }
}
void pop1(int stack11[],int stack21[])//从第一个栈弹出给第二个,必须堆栈中用东西才可以弹出
{
    int i;
    int j;
    int tmppop1;
    for(i=0; i<50; i++)
    {
        if(stack11[i]<=-9999)
        {
            tmppop1=stack11[0];
            if(i==0)
            {

            }
            else
            {
                for(j=0; j<i; j++)
                {
                    stack11[j]=stack11[j+1];
                }
                break;
            }
        }
    }
    push1(stack21,tmppop1);
}
int change(char aa)
{
    int i;
    int j;
    if(aa=='#')
    {
        flag = flag + 1;
    }
    if(flag==0)
    {
        printf("还未遇到#");
    }
    else
    {
        if(flag==1)
        {
            switch (aa)
            {
            case '(':
                printf("压入%c\n",aa);
                push(stack,aa);
                break;
            case ')':
                for(i=0; i<50; i++)
                {
                    if(stack[i]=='(')
                    {
                        for(j=0; j<i; j++)
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);

                        }
                        printf("弹出从算符堆栈到nouse%c\n",stack[0]);
                        pop(stack,nouse);
                        break;
                    }
                }
                break;
            case '+':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if(((stack[0]=='*')||(stack[0]=='/'))&&(stack[0]!='('))
                    {
                        printf("弹出从算符堆栈到output%c\n",stack[0]);
                        pop(stack,output);
                        if((stack[0]=='+')||(stack[0]=='-'))
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                    else
                    {
                        if(stack[0]=='(')    //这个位置之前不小心写成了aa，碰到不会的别慌，赶紧用printf检查在哪里附近出了问题与然后细心排查错误！！！
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            case '-':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if(((stack[0]=='*')||(stack[0]=='/'))&&(stack[0]!='(')&&(stack[0]!='%'))
                    {
                        printf("弹出从算符堆栈到output%c\n",stack[0]);
                        pop(stack,output);
                        if((stack[0]=='+')||(stack[0]=='-'))
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                    else
                    {
                        if(stack[0]=='(')
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            case '*':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if((stack[0]=='+')||(stack[0]=='-')||(stack[0]!='('))
                    {
                        printf("压入%c进入算符堆栈\n",aa);
                        push(stack,aa);
                    }
                    else
                    {
                        if(stack[0]!='(')
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            case '/':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if((stack[0]=='+')||(stack[0]=='-')||(stack[0]!='('))
                    {
                        printf("压入%c进入算符堆栈\n",aa);
                        push(stack,aa);
                    }
                    else
                    {
                        if(stack[0]!='(')
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            case '%':
                if(stack[0]=='\0')
                {
                    printf("压入%c进入算符堆栈\n",aa);
                    push(stack,aa);
                }
                else
                {
                    if((stack[0]=='+')||(stack[0]=='-')||(stack[0]!='('))
                    {
                        printf("压入%c进入算符堆栈\n",aa);
                        push(stack,aa);
                    }
                    else
                    {
                        if(stack[0]!='(')
                        {
                            printf("弹出从算符堆栈到output%c\n",stack[0]);
                            pop(stack,output);
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                        else
                        {
                            printf("压入%c进入算符堆栈\n",aa);
                            push(stack,aa);
                        }
                    }
                }
                break;
            default:
                if(aa=='#')
                {
                    ;

                }
                else
                {
                    printf("压入%c进入output\n",aa);
                    push(output,aa);
                }
                break;
            }
        }
        else
        {
            flag=flag-2;
            return 2;
        }
    }
}


void  WritetoFile(char wenjian[])
{
    FILE *fp;
    int flag;
    flag=1;
    if((fp = fopen("zhongzhui.txt","w"))==NULL)
    {
        printf("写入文件失败\n");
        flag=0;
    }
    if(flag==1)
    {
    printf("已经成功将中缀表达式写入文件\n");
    fprintf(fp,"%50s",wenjian);
    fclose(fp);
    }
}

void  ReadfromFile(char wenjian1[])
{
     FILE *fp;
     int flag;
     flag=1;
     if((fp=fopen("zhongzhui.txt","r"))==NULL)
     {
        printf("读取文件失败\n");
        flag=0;
     }
     if(flag==1)
     {
     fscanf(fp,"%50s",wenjian1);
     printf("读取到的中缀表达式为%s\n",wenjian1);
     }
     fclose(fp);
}

int main()
{
    int i;
    int j;
    int loog;
    int tmp6;
    char zh[50];
    char dz[50];
    char fuhao[50];
    int zzbsf[50];
    int xunhuan;
    for(xunhuan=0;xunhuan<=20;xunhuan++)
    {
        for(i=0; i<50; i++)
    {
        zzbsf[50]='\0';
        stack[i]='\0';
        output[i]='\0';
        zh[i]='\0';
        nouse[i]='\0';
        dz[i]='\0';
        fuhao[i]='e';
        sz[i]='\0';
        szz[i]=-20000;
        jieguo[i]=-20000;
        laji[i]=-20000;
        wuyong[i]=-20000;
    }
    printf("请输入表达式，开始需要输入#\n");
    scanf("%s",zh);
    printf("\n");
    strcpy(zzbsf,zh);
    for(i=0; i<50; i++)
    {
        if(zh[i]=='\0')
        {
            break;
        }
        else
        {
            if(change(zh[i])==2)
            {
                break;
            }
        }
    }
    for(j=0; j<=50; j++)
    {
        if(stack[j]!='\0')
        {
            push(output,stack[j]);
        }
        else
        {
            break;
        }
    }
    pop(output,nouse);
    for(i=0; i<50; i++)
    {
        if(output[i]=='\0')
        {
            output[i-1]='\0';
            break;
        }
    }
    strcpy(dz,output);
    for(i=0; i<50; i++)
    {
        if(output[i]=='\0')
        {
            for(j=0; j<i; j++)
            {
                output[i-j-1]=dz[j];
            }
            break;
        }
    }
    tmp6=0;
    printf("\n");
    pop(zzbsf,nouse);
    printf("中缀表示法为%s\n",zzbsf);
    printf("\n");
    printf("后缀表示法为%s\n",output);

    getchar();
    for(i=0; i<50; i++)
    {
        if(output[i]=='\0')
        {
            break;
        }
        else
        {
            if((output[i]!='+')&&(output[i]!='-')&&(output[i]!='*')&&(output[i]!='/')&&(output[i]!='%'))
            {
                printf("请输入您要输入\n");
                printf("请输入字符%c对应的数值类型\n",output[i]);
                printf("1.数字\n");
                printf("2.ln\n");
                printf("3.取绝对值\n");
                scanf("%d",&loog);
                getchar();
                printf("请输入\n");
                if(loog==1)
                {
                scanf("%d",&tmp6);
                getchar();
                szz[i]=tmp6;
                }
                else
                {
                    if(loog==2)
                    {
                scanf("%d",&tmp6);
                getchar();
                szz[i]=log(tmp6);
                    }
                    else
                    {
                scanf("%d",&tmp6);
                getchar();
                szz[i]=abs(tmp6);
                    }
                }
            }
            else
            {
                switch (output[i])//switch语句别忘了加大括号！！！
                {
                case '+':
                    szz[i]=80001;
                    break;
                case '-':
                    szz[i]=80002;
                    break;
                case '*':
                    szz[i]=80003;
                    break;
                case '/':
                    szz[i]=80004;
                    break;
                case '%':
                    szz[i]=80005;
                    break;
                default:
                    szz[i]=-30000;
                    break;
                }
            }
        }
    }

    for(j=0; j<50; j++)
    {
        if(szz[0]<=-9999)
        {
            break;
        }
        else
        {
            if((szz[0]==80001)||(szz[0]==80002)||(szz[0]==80003)||(szz[0]==80004)||(szz[0]==80005))
            {
                pop1(szz,wuyong);
                switch ((int)(wuyong[0]))
                {
                case 80001:
                    printf("弹出+并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]+jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]+wuyong[1]));
                    break;
                case 80002:
                    printf("弹出-并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]-jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]-wuyong[1]));
                    break;
                case 80003:
                    printf("弹出*并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]*jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]*wuyong[1]));
                    break;
                case 80004:
                    printf("弹出/并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d+%d=%d",jieguo[1],jieguo[0],jieguo[1]/jieguo[0]);
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]/wuyong[1]));
                    break;
                case 80005:
                    printf("弹出%并进行相应计算\n");
                    printf("弹出%d\n",jieguo[0]);
                    printf("弹出%d\n",jieguo[1]);
                    printf("压入%d quyu  %d=%d\n",jieguo[1],jieguo[0],(int)(jieguo[1])%(int)(jieguo[0]));
                    pop1(jieguo,wuyong);
                    pop1(jieguo,wuyong);
                    push1(jieguo,(wuyong[0]%wuyong[1]));
                    break;
                }
            }
            else
            {
                printf("压入数字%d\n",szz[0]);
                pop1(szz,jieguo);
            }
        }
    }
    printf("中缀表达式的计算结果为%d\n",jieguo[0]);
    printf("如果想读入文件请输入1，否则请输入2\n");
    scanf("%d",&j);
    if(j==1)
    {
    WritetoFile(output);
    }
    else
    {
        ;
    }
    printf("如果想读取文件并显示请输入1，否则请输入2\n");
    scanf("%d",&j);
    if(j==1)
    {
       ReadfromFile(output) ;
    }
    else
    {
        ;
    }
    }

    return 0;
}
C编译器剖析_5.2.4 中间代码生成及优化_后缀表达式的翻译
SheIsC的专栏
04-17 1417
5.2.4 后缀表达式的翻译     在前面的章节中，我们介绍了用于对数组元素和结构体成员进行访问的函数Offset，其接口如下所示，参数addr代表了基地址，参数voff代表可变偏移，而参数coff则代表常量偏移。          Symbol Offset(Type ty, Symbol addr,Symbol voff, int coff)；     函数Offset的基本想法是产生
（附代码）中缀表达式转化为后缀表达式（可含括号，可含小数），并计算后缀表达式的结果
lolitaaaa的博客
03-29 560
应知道，计算机不好处理中缀表达式，最好转化为后缀表达式计算 代码附在文末 代码思想：（皆按代码编写顺序解释） First, 若中缀表达式用string表示，需先将其拆分为运算符( +,-,*,/,(,) )和运算数，存在列表list中以便处理 Second, 我们需要一个栈Stack_op，来暂存运算符（现在还轮不到它来算的） 我们需要一个队列（列表也行）Que_final，来按顺序依次存放后缀表达式的元素 Third, 我们遍历中缀list，获得当前位置元素elem （1）如果当前元素
中缀表达式转化成后缀表达式，优化版本1
weixin_40128696的博客
08-10 132
package org.structure.stack; import java.util.ArrayList; import java.util.Stack; /** * 中缀表达式转化成后缀表达式的过程 * @author cjj_1 * @date 2020-08-07 15:05 */ public class ToSuffix { public static void main(String[] args) { Stack<String> s1= ne
后缀表达式
WenOOI的博客
12-16 1799
题目描述 所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。 如：3*(5–2)+7对应的后缀表达式为：3．5．2．-*7．+@。’@’为表达式的结束符号。‘.’为操作数的结束符号。 输入格式： 输入：后缀表达式 输出格式： 输出：表达式的值 #incl
后缀表达式计算
走马观花
10-16 1353
http://www.cppblog.com/deep2/archive/2008/10/25/65021.aspx   // test20.cpp : Defines the entry point for the console application. // #include "stdafx.h" #includeiostream> #includestack> #incl
后缀树完整优化方案
qq_36172410的博客
04-29 252
————《高级数据结构》 技巧一： 每条边维护对应字串的长度（一下简计为边的长度Length(edge)）。回想后缀树的定义（这里是隐式树），“从同一个节点映出的任意两条边上标的字符出纳都不会以相同字符开始”，所以我们只需要知道引出边的第一个字符串都不会以相同字符开始，所以我们只需要把知道引出边的第一个字符就知道往哪里走了。而该边的其他字符我们并不需要一个一个检验，只需要比对对应的子串长度与当前要...
c语言编写浮点数计算器带括号,带括号浮点型计算器final
weixin_39629467的博客
05-25 571
//Copyrightbyabilitytao//Allrightnotreserved!!#include#include#include#include#include#include//添加的头文件，用于进行后缀表达式计算操作；#include//添加的头文件，用于字符串处理；#include//添加的头文件，仅仅为了使用isdigit函数；usingnamespacestd;st...
【算法】表达式求值--逆波兰算法介绍
Curtis’Blog
06-19 707
【算法】表达式求值--逆波兰算法介绍 转自：https://www.cnblogs.com/lulipro/p/7450886.html 逆波兰算法介绍 假定给定一个只 包含 加、减、乘、除，和括号的算术表达式，你怎么编写程序计算出其结果？ 问题是：在表达式中，括号，以及括号的多层嵌套 的使用，运算符的优先级不同等因素，使得一个算术表达式在计算时，运算顺序往往因表达式的内容而定，不具规...
C语言实现科学计算器的加减乘除平方开放运算
weixin_45616941的博客
09-22 1355
本程序可以对 “输入的表达式” 和 “从文件里面读入的表达式” 进行运算 并且支持对负号的处理 代码运行时有一个警告信息 ，但是不影响运行和最终的结果。不知道问题出在哪！ #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<ctype.h> #include<math.h> #include<string.h> #include<iostr
【墨尘の笔记】数据结构与算法
IntFase的博客
04-20 1251
前言 仙人指路 [第一章](# 第一章)为入门，讲解数据结构是干什么的 [第二章](# 第二章)到第四章是数据结构基础，主要讲解链表，栈，队列，串等 [第五章](# 第五章)是二叉树 [第六章](# 第六章)是图,此章偏难，非考研或算法从业可粗略看 [第七章](# 第七章)到第八章是查找以及各种排序 [第九章](# 第九章)为补充，教材中没有的部分概念我随机补充上去 墨尘の话 本文内容主要参考王道考研，其中21版本咸鱼学长的课尚可，20版本比较枯燥,可选择性学习 浙大陈越姥姥的课比较精简且侧重于练习，能看懂
c语言表达式的后缀,C语言后缀表达式计算.doc
weixin_36050671的博客
05-18 662
C语言后缀表达式计算一、设计思想计算算数表达式并求值，采取的共有两种方法：先将算数表达式转化为后缀表达式，然后对后缀表达式进行计算。对算数表达式进行直接的计算。第一种算法这种解决方案又分为两步：1.将表达式先转化为后缀表达式的字符串数组2.利用后缀表达式进行计算在转化过程中，第一，建立一个存符号的栈，和一个字符串数组，用来存放转化以后的表达式然后，对于得到的用户输入的字符串进行逐个的扫描，如果是数...
栈解决中缀表达式转后缀表达式_中缀表达式转后缀表达式后计算结果
weixin_39668571的博客
11-23 109
前段时间自学java想做个画函数图像的app才发现：java里没有eval函数！无奈之下只能学习下计算表达式的过程：后缀表达式。1.人脑计算（中缀表达式）我们计算一个式子是从左往右看，遇到数先保留在脑子里，遇到运算符也先存在大脑，接着遇到下一个数，还得看看这个数后面有没有更高等级的运算符，遇到左括号得把之前的东西都先放着，再往后看，直到遇到右括号再算括号里的东西，然后再按照运算优先级，以3+4*(...
c语言程序算法思想,C语言实现科学计算器（算法思想）
weixin_39856803的博客
05-17 456
程序设计目的是用户可以输入中缀表达式，回车后计算出结果。首先要知道中缀表达式如何转换成后缀(前缀)表达式，中缀表达式是人容易理解的表达式，而对计算机来说，计算中缀表达式是很困难的。所以我们先把中缀表达式转化成后缀表达式或者转换成前缀表达式后在计算。中缀表达式是区分运算符优先级的，由于不同的运算符间存在优先级，同一优先级的运算间又存在着运算结合问题。所以简单地从左往右的计算是不可以的。而前缀和后缀表...
C语言后缀表达式求值
程序设计
08-30 2455
从控制台输入一合法的后缀表达式，其中的运算符只包括+、一、*、/，运算数都是大于等于o的整数（除数不为零)，按要求输出计算结果，或输出计算结和相对应的中缀表达式。输出中缀表达式时只包含最少数目的圆括号(即在生成的中缀表达式中若去掉一对括号，则其将不能够转换回输入的后缀表达式)。输出计算结果时，小数点后保留两位，例如:10/3的结果为3.33。假如输入的后缀表达式为:其相对应的中缀表达式为:计算结果为109.50。【输入形式】...
用后缀表达式计算四则运算算法
yichudu
04-24 3970
1*2+3*4, 这个对应的中缀表达式就是[1,*,2,+,3,*,4], 需要转换成后缀表达式[1,2,*,3,4,*,+], 才能进一步计算得到结果.1.得到后缀表达式需要准备两个容器, 符号栈 operatorStack 与 盛放后缀表达式的队列 expQueue. 按照下列规则从前到后遍历中缀表达式. 遇到数字num, 就expQueue.push(num); 若遇到操作符, 分两步处理
C语言中缀表达式转化为后缀表达式
weixin_43919162的博客
12-12 1925
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &lt;stdbool.h&gt; //别靠空想！！！及其浪费时间！！！多谢谢伪代码分析一下！！！ //后缀表示法计算时候的思路！！！先把元素推到栈中，每碰到一个 char stack[50]; char output[50];...
C语言中缀转后缀四则运算--For初学者
a_52hz的博客
09-26 1816
中缀表达式 百度百科 后缀表达式 百度百科 现在大家都知道了什么是中缀表达式，后缀表达式。好，进正题。本文主要是用C语言，来做简单的编程实现转化功能。 例如，输入 ：(5+3)*2+(6+3) 转化后的结果：5 3 + 2 * 6 3 + +（后附有图） 额，本人能力有限，所以难免有bug，读者在运行代码的时候，括号的输入是英文的（可以自行加上中文），注意输入格式。 代码如下： 编译环境是（Cod...
中缀表达式转后缀表达式（c语言）
myCsdn_Xm的博客
06-29 8820
中缀表达式是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间，是人们常用的算术表示方法。后缀表达式指的是不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行(不再考虑运算符的优先规则)。1、遇到操作数，直接输出。2、如果不是操作数，分为以下几种情况（1）如果操作符栈为空，则入栈。（2）如果栈非空，且当前操作符优先级大于栈顶操作符，则入栈；如...
C++ STL学习之stack
AC_AC_的博客
07-31 3223
栈一种先进先出。后进后出的容器适配器，图形如下，只能从栈顶入，栈顶出。 功能介绍 1.头文件 #include&lt;stack&gt; 2.定义：stack&lt;int &gt;s,int类型                stack&lt;char&gt;s,char类型的，                stack&lt;double&gt;,double类型的，     ...
C语言实现中缀表达式到后缀表达式的转换
将中缀表达式转化为后缀表达式（Reverse Polish Notation, RPN），也称为逆波兰表示法，是一种常见的转换过程，它有助于简化计算流程和优化算法执行效率。后缀表达式的特点是没有括号，所有的操作符都位于操作数之后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值