用C语言实现字符串转表达式并计算结果

最新推荐文章于 2023-12-02 21:00:34 发布
原创 最新推荐文章于 2023-12-02 21:00:34 发布 · 3.3k 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c语言 #c++ #开发语言 #数据结构
本文介绍了如何使用C语言将中缀表达式转换为后缀表达式并进行计算。通过栈操作处理运算符的优先级，详细步骤包括中缀转后缀以及后缀表达式的计算过程。程序支持整数、小数和科学计数法，涵盖基本算术运算符。读者可在评论区讨论或留言获取更多细节。

用C语言实现字符串转表达式并计算结果

原理：用栈操作将中缀表达式转换为后缀表达式，再将后缀表达式计算。（需要特别注意运算符的优先级）。
中缀转后缀：读到操作数时，将其放到输出中，操作符用栈保存，特别注意运算符的优先级。（详细原理可查阅资料）
后缀计算：将读到的操作数保存到栈，读到操作符时将栈中两个操作数出栈，并与该操作符进行运算，再将计算结果压栈，特别要注意需要做好错误处理。
注意：栈可分别建立一个数据栈和一个操作符栈。该程序支持小数 整数 科学计数法 ,运算符支持+ - * / 幂（^）需要其他操作可在此基础上添加。
需要详细说明可留言或评论区讨论。
代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define STACK_SIZE 512

typedef enum ElemDataType
{
    OPERATOR = 1,
    INT,
    DOUBLE,
    POINTER
} ElemDataType;

typedef struct StackElem
{
    ElemDataType type;
    union {
        char op;
        int i;
        double d;
        void *p;
    };
} ElemType;

ElemType elemFromOperator(char c)
{
    ElemType ret = {.type = OPERATOR, .op = c};
    return ret;
}

ElemType elemFromInt(int i)
{
    ElemType ret = {.type = INT, .i = i};
    return ret;
}

ElemType elemFromDouble(double d)
{
    ElemType ret = {.type = DOUBLE, .d = d};
    return ret;
}

ElemType elemFromPointer(void* p)
{
    ElemType ret = {.type = POINTER, .p = p};
    return ret;
}

// ADT: Expression
//==================================================================
typedef struct Expression
{
    int size;
    int capacity; // 容量
    ElemType *tokens;
} Expression;

void initExpression(Expression *pExpr)
{
    if (pExpr == NULL)
    {
        return;
    }
    pExpr->size = 0;
    pExpr->capacity = 10;
    pExpr->tokens = malloc(sizeof(ElemType) * pExpr->capacity);
}

// 扩容
void expandExpression(Expression *pExpr, int newCapcity)
{
    if (pExpr == NULL)
    {
        return;
    }
    if (newCapcity <= pExpr->capacity * 2)
    {
        newCapcity = pExpr->capacity * 2;
    }
    ElemType* newTokens = malloc(sizeof(ElemType) * newCapcity);
    memcpy(newTokens, pExpr->tokens, sizeof(ElemType) * pExpr->capacity);
    free(pExpr->tokens);
    pExpr->tokens = newTokens;
}

void appendToken(Expression *pExpr, ElemType elem)
{
    if (pExpr == NULL)
    {
        return;
    }
    if (pExpr->size == pExpr->capacity)
    {
        expandExpression(pExpr, 0);
    }
    pExpr->tokens[pExpr->size] = elem;
    pExpr->size ++;
}

void clearExpression(Expression *pExpr, ElemType type)
{
    if (pExpr == NULL)
    {
        return;
    }
    pExpr->size = 0;
}

void freeExpression(Expression *pExpr)
{
    if (pExpr == NULL || pExpr->tokens == NULL)
    {
        return;
    }
    free(pExpr->tokens);
    pExpr->tokens = NULL;
    pExpr->size = 0;
}

// ADT: Stack
//==================================================================
struct Stack
{
    ElemType datas[STACK_SIZE];
    int top;
};
typedef struct Stack Stack;

//检测是否为空
int isEmpty(Stack *stack)
{
    return stack->top == -1;
}

int getStackSize(Stack *stack)
{
    return stack->top < 0 ? 0 : stack->top + 1;
}

//初始化
void clear(Stack *stack)
{
    stack->top = -1;
}

//判断是否栈满
int isFull(Stack *stack)
{
    return stack->top == STACK_SIZE - 1;
}

//进栈、压栈
int push(Stack *stack, ElemType val)
{
    if (isFull(stack))
    {
        printf("push element to a full stack\n");
        return 0;
    }
    stack->datas[++stack->top] = val;
    return 1;
}
// 获取栈顶元素
int getStackTop(Stack *stack, ElemType *topElem)
{
    if (isEmpty(stack))
    {
        printf("get top of a empty stack\n");
        return 0;
    }
    *topElem = stack->datas[stack->top];
    return 1;
}
//出栈
int pop(Stack *stack)
{
    if (isEmpty(stack))
    {
        printf("pop a empty stack\n");
        return 0;
    }
    stack->top--;
    return 1;
}
//==================================================================

int isDigit(char c)
{
    return c >= '0' && c <= '9';
}

int isOperator(char c)
{
    return c == '+' || c == '-' || c == '*' || c == '/' || c == '^';
}

int getPriority(char c)
{
    switch (c)
    {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        case '^':
            return 3;
    }
    return 0;
}

double calculateOp(char op, double val1, double val2)
{
    if (op == '+')
    {
        return val1 + val2;
    }
    if (op == '-')
    {
        return val1 - val2;
    }
    if (op == '*')
    {
        return val1 * val2;
    }
    if (op == '/')
    {
        return val1 / val2;
    }
    if (op == '^')
    {
        return pow(val1, val2);
    }
    printf("unkown operator %c\n", op);
    return -1;
}

// return value : 0 invalid 1 valid
int infixToPostfix(Stack *pStack, Expression *pExpr, char* str)
{
    if (pStack == NULL || pExpr == NULL || str == NULL)
    {
        return 0;
    }
    int i = 0;
    while (str[i] != '\0')
    {
        while (str[i] == ' ' || str[i] == '\t')
        {
            i++;
        }
        if (isDigit(str[i]))
        {
            double value = 0;
            while (isDigit(str[i]))
            {
                value = value * 10 +  str[i] - '0';
                printf("%c", str[i]);
                i++;
            }
            if (str[i] == '.')
            {
                i++;
                double fraction = 0.0;
                double magnitude = 0.1;
                if (!isDigit(str[i]))
                {
                    printf("invalid floating point number, no digits after .\n");
                    return 0;
                }
                while (isDigit(str[i]))
                {
                    fraction += magnitude * (str[i] - '0');
                    magnitude *= 0.1;
                    i ++;
                }
                value += fraction;
            }
            if (str[i] == 'e' || str[i] == 'E')
            {
                i++;
                int negative = 0;
                if (str[i] == '-')
                {
                    negative = 1;
                    i++;
                }
                if (!isDigit(str[i]))
                {
                    printf("missing exponent after e/E\n");
                    return 0;
                }
                
                int exponent = 0;
                while(isDigit(str[i]))
                {
                    exponent = exponent * 10 + str[i] - '0';
                    i++;
                }
                if(negative == 1)
                {
                    exponent = -exponent;
                }
                value = value *pow(10, exponent);
                

            }
            printf(" ");
            appendToken(pExpr, elemFromDouble(value));
            continue;
        }
        else if (str[i] == '(')
        {
            push(pStack, elemFromOperator(str[i]));
        }
        else if (str[i] == ')')
        {
            if (isEmpty(pStack))
            {
                printf("missing (\n");
                return 0;
            }
            ElemType elem = {};
            getStackTop(pStack, &elem);
            while (elem.op != '(' && !isEmpty(pStack))
            {
                printf("%c ", elem.op);
                appendToken(pExpr, elemFromOperator(elem.op));
                pop(pStack);
                if (isEmpty(pStack))
                {
                    printf("missing (\n");
                    return 0;
                }
                getStackTop(pStack, &elem);
            }
            if (isEmpty(pStack))
            {
                printf("missing (\n");
                return 0;
            }
            pop(pStack);
        }
        else if (isOperator(str[i]))
        {
            if (isEmpty(pStack))
            {
                push(pStack, elemFromOperator(str[i]));
            }
            else
            {
                ElemType elem = {};
                getStackTop(pStack, &elem);
                while (elem.op != '(' && !isEmpty(pStack) && getPriority(str[i]) <= getPriority(elem.op))
                {
                    printf("%c ", elem.op);
                    appendToken(pExpr, elemFromOperator(elem.op));
                    pop(pStack);
                    if (isEmpty(pStack))
                    {
                        break;
                    }
                    getStackTop(pStack, &elem);
                }
                push(pStack, elemFromOperator(str[i]));
            }
        }
        else
        {
            printf("invalid character %c\n", str[i]);
            return 0;
        }
        i++;
    }
    while (!isEmpty(pStack))
    {
        ElemType elem = {};
        getStackTop(pStack, &elem);
        pop(pStack);
        if (elem.op == '(')
        {
            printf("missing )\n");
            return 0;
        }
        else
        {
            printf("%c ", elem.op);
            appendToken(pExpr, elemFromOperator(elem.op));
        }
    }
    printf("\n");
    return 1;
}

int calculatePostfix(Expression *pExpr, double *pRes)
{
    if (pExpr == NULL || pRes == NULL)
    {
        return 0;
    }
    Stack stack;
    clear(&stack);
    int i = 0;
    for (i = 0; i < pExpr->size; i ++)
    {
        ElemType elem = pExpr->tokens[i];
        if (elem.type == DOUBLE)
        {
            push(&stack, elem);
        }
        else if(elem.type == OPERATOR)
        {
            if (!isOperator(elem.op))
            {
                printf("invalid operator %c\n", elem.op);
                return 0;
            }
            if (isEmpty(&stack))
            {
                printf("missing value\n");
                return 0;
            }
            ElemType valElem1 = {}, valElem2 = {};
            getStackTop(&stack, &valElem1);
            pop(&stack);

            if (isEmpty(&stack))
            {
                printf("missing value\n");
                return 0;
            }
            getStackTop(&stack, &valElem2);
            pop(&stack);
            push(&stack, elemFromDouble(calculateOp(elem.op, valElem2.d, valElem1.d)));
        }
    }

    if (isEmpty(&stack))
    {
        printf("empty expression\n");
        return 0;
    }
    if (getStackSize(&stack) > 1)
    {
        printf("missing operator\n");
        return 0;
    }
    ElemType elem = {};
    getStackTop(&stack, &elem);
    *pRes = elem.d;
    return 1;
}
//测试函数
// a simplest test framework
//=====================================================================================
static int count = 0;
static int passedCount = 0;
void test(char* str, int expectedValid, double exptectedRes)
{
    Stack stack;
    clear(&stack);
    Expression expr;
    initExpression(&expr);
    int valid1 = infixToPostfix(&stack, &expr, str);
    double actualResult = 0;
    int actualValid = valid1 ? calculatePostfix(&expr, &actualResult) : 0;

    int pass = expectedValid == actualValid && (expectedValid == 0 || (exptectedRes - actualResult) <= 1e-10 * exptectedRes
    ||exptectedRes * actualResult>0 && isinf(exptectedRes) == isinf(actualResult));
    count ++;
    passedCount += pass ? 1 : 0;
    printf("case %d %s, input : %s, valid: %d, expected result: %lf, actual result: %lf\n", 
        count, pass ? "passed" : "failed", str, expectedValid, exptectedRes, actualResult);
}
//计算结果测试
int main()
{
    // integer
    test(" 1 / 2 * 3", 1, 1 / 2 * 3);
    test("(", 0, 0);
    test("1+", 0, 0);
    test("100+(10 * 2 / 5 * (3 - 2 + 5)) * (100-10)", 1, 100+(10 * 2 / 5 * (3 - 2 + 5)) * (100-10));
    test("100+(10 * 2 / 5 * (3 - 2 + 5) * (100-10)", 0, 0);
    test("+1", 0, 0);
    test("&", 0, 0);
    test("10^2", 1, pow(10, 2));
    test("1.123421890 * 1234801.1234123 / 12342.2134123", 1, 1.123421890 * 1234801.1234123 / 12342.2134123);
    test("1.1234235^2.213412 * 100.809774551 ^ 41.87012342", 1, pow(1.1234235, 2.213412) * pow(100.809774551, 41.87012342));
    test("32425+324e-3+32423.34324", 1, 32425+324e-3+32423.34324);
    test("324223e-23+7298437+234.1^20", 1, 324223e-23+7298437+pow(234.1, 20));
    printf("total : %d, passed: %d, failed: %d\n", count, passedCount, count - passedCount);
    return 0;
}
//T.M

运行结果：测试成功

Gui_H
关注
字符串转换为计算公式的若干种方法
05-18
个人收集的几种将字符串表达式转换为计算公式的方法。
VC++程序: 将字符串转换成公式并计算结果
10-23
int Calculate(string formula) 函数功能：输入一个字符串公式string formula，允许四则混合运算，然后输入公式中对应变量的取值，最后返回int类型计算结果。 变量的格式：必须由1位字母加1位数字组成，如a1、b2等。 如输入字符串 “(a1+b2)/(-100)”，以及a1=100,b2=300,得到结果-4。遇到小数则向下取整。 公式的格式： 1、只包含变量、常数、四则符号、小括号四种符号，不支持大括号和中括号 2、允许正数前加正号，如+100 3、不允许空括号，如 “8*（ ）” 4、允许负数，但负数必须加括号，如 "5/（-1）"。当负数在公式开头时，可不加括号， 如 "-a1+90"和“+a1+90” 都是对的 5、允许纯常数公式，如 “5*（-9）” 6、允许用户输入多余的空格,但空格不能造成公式错误， 如公式 “（1 08+a2)/a 3” 是错的，(- 7)和(- n5)是错的，去掉空格就对了。
C语言中缀表达式转成后缀表达式，并计算它的值
奋斗的龙猫的博客
04-07 6627
在C语言中，将中缀表达式转成后缀表达式，并计算它的结果，具体的思路如下： 1、定义两个栈，numStack用于存放运算对象，最后存放运算结果的，fuStack用于存放运算符号的 2、从左到右遍历字符串 3、如果当前的字符是一个数字，那么先不要着急将其转成数字，然后压入到numStack中，因为考虑到多位数字的情况，所以需要从当前下标开始遍历，一直遍历到第一个运算符出现，那么这时候才可以将运算符前面的数字转成字符串。然后调用atoi,将字符串转成一个数字。这时候，将这个数字输出，同时将其压入到numStack
字符串如何转换成表达式运算
Wl131415的博客
03-14 1546
字符串转表达式运算
任意字符串转换成数学表达式
worsun的专栏
04-30 3809
还好我宝刀未老，嘿嘿，您要的这个程序，连写带测试，用了3个多小时(别说我菜，毕竟我是专门为了你工作3个多小时啊)。 事先声明，这玩意不好整，若您只是一时起兴，那么看看代码就可以了，若您是真想研究，那么不懂的地方可以私聊我。 您说的题目，就是数据结构里的“表达式求值”问题。 问题：给出一个表达式，其内包含(、)、+、-、*、/、%等运算符，要求写出程序，计算出表达式的值。 其实，这个问
实现带有括号的四则运算c语言程序,带括号的四则运算C语言实现
weixin_35968240的博客
05-17 1804
#include#include#include#include#include/************************************************************************** int CheckNum(char *c) 输入参数： char *c: 输入的字符串 返回参数： 0：字符串中有不符合规定的字符 1: 字符串字符符合规定，没有不符合...
c语言字符串表达式计算,表达式计算（C语言版）
weixin_29802461的博客
05-17 1704
#include"stdlib.h"typedef double DataType; /*数据存放类型*/typedef int OpType; /*运算符存放类型*/char *code = "+-*/()#"; /*运算符串*/char priority[7][7] = {'>','>','','>','>','>','','>','...
中缀表达式转后缀表达式并计算（C语言）
chaogewudi34的博客
02-24 832
中缀表达式转后缀表达式并计算（C语言）
C语言入门--输入和输出函数的运用
m0_67587064的博客
12-02 658
事实上，库函数的由来是因为程序员在开发过程中经常用到某些功能，而编写这些功能又会大量的消耗时间，所以各个编译器的厂商将这些功能打包好制作成了库函数，提高了编程效率。h，i，o分别是一个单词的首字母，.h代表头文件的意思，i -- input，o -- output，h -- head。因此，printf显示了第二个实参20+32的值，即52，加上前面的字符串，结果是20与32的和是52。int是main函数的返回类型，这里返回的是整型（整数）的值，（）里面是函数的参数。注意:程序中的引号（"）、分号(;
字符串转数学表达式进行计算
一只小菜鸟的进阶历程
02-14 2597
做web的同学经常会遇到在jsp下计算的问题，建议使用eval()函数 可以直接在谷歌F12 console下执行：eval( "(3+5-(2-4)*2)/24") 实战样例： var gs = "物料/规模/时间"; var sz=["物料,100","规模,2","时间,5"]; //用数组的参数来替换gs。 for(var i=0;i&lt;sz.length;i++){  ..
表达式求值
代码行
04-06 9263
1792: 算法3-4：表达式求值 时间限制:1 Sec内存限制:32 MB 提交:34解决:22 [提交][状态][讨论版] 题目描述 算数四则运算的规则是1）先乘除，后加减；2）从左算到右；3）先括号内，后括号外。 由此，算式4+2*3-10/5的计算顺序为4+2*3-10/5=4+6-10/5=4+6-2=8。 给定一个以“#”作为结束符的算式，求出算式的结果。 ...
C语言实现表达式分析并输出结果，注意：在处理小数的时候选择了向上向下取整，我暂时也没有能力解决。对了，代码也不是我的，也是曾经从CSDN上抄下来的，如有侵权，实在抱歉，第一次使用，请提醒我撤销，谢谢。
m0_51102494的博客
10-26 311
#include<stdio.h> #include<stdlib.h> #include #include <malloc.h> #include <string.h> #define STACK_INIT_SIZE 100 //存储空间初始分配量 #define STACKINCREMENT 10 //存储空间分配增量 #define OVERFLOW -2 #define OK 1 #define ERROR 0 #define
c++输入字符串计算出算式结果
weixin_42608318的博客
01-08 1020
你可以使用 C 语言的 eval() 函数来计算输入的字符串表达式的结果。 eval() 函数定义在头文件 stdlib.h 中，使用时需要包含该头文件。 例如，如果要计算输入字符串 "2 + 3" 的结果，可以使用如下代码： #include <stdlib.h> #include <stdio.h> int main() { char input[] = "2...
C语言 计算给定字符串表达式的值
wzw
06-13 5632
C语言 计算给定字符串表达式的值 可以包括加减乘除运算以及括号运算 代码 #include<stdio.h> #include<string.h> #define maxn 100005 char s[maxn],infixList[maxn][10]; char suffix[maxn][10]; int p=0; char tmp[maxn]; int p1=0; //把字符串根据操作数、运算符、括号拆开，存储到infixList数组中 int toInfixE.
C语言——字符串，运算符和表达式之算术
m0_74447662的博客
11-01 1878
C语言——字符串，运算符和表达式之算术
一种能将字符串转换为算式并给出结果的算法
03-09 1475
这个算法，应该是我到大学写的第一个递归，其实要点就是那个括号总是不匹配，解决方法就是自己写个计数器。    主文件： #include #include #include #include #include using namespace std; string LastErrorText=""; string LastText=""; extern string sonsin(string
C语言算术表达式求值
m0_74144989的博客
09-21 787
else if (a[i]=='('&&a[i-1]>=48&&a[i-1]<=57) {printf("表达式错误\n");//规则4-b-1 栈顶运算符弹出并打印, 调用Calculation(snum,old_ope)结果入snum栈。//并调用Calculation(snum,old_ope)结果入snum栈 直到遇到左括号。//规则4-b Priority(ope) <= Priority(old_ope。//规则4-a Priority(ope) > Priority(old_ope。
计算表达式的值------C语言
m0_58548839的博客
10-28 2262
今天的题目开始利用代码开始计算表达式的值，不管是在生活中我们的计算还是在电脑的计算，我们都注意的是计算的运算法则，在计算机也有计算法则，有符号的先后顺序，下面附一张运算符优先级图表： 1.题目 题目描述： 请计算表达式“(-8+22)×a-10+c÷2”，其中，a = 40，c = 212。 输入描述： 无。 输出描述： (-8+22)×a-10+c÷2计算之后的结果，为一个整数。 2.参考代码 代码如下（示例）： #include <stdio.h> int main() { int a=
基于C++实现表达式转换
毕业作品网站
08-16 1733
如何将表达式翻译成能够正确求值的指令序列，是语言处理程序要解决的基本问题。任何一个表达式都是由操作数、操作符和分界符组成的。算数表达式有前缀表示法、中缀表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表达式，即二元运算符位于两个运算数中间。为了正确执行这种中缀表达式的计算，必须明确各个操作符的执行顺序。为此每个操作符都规定了一个优先级。C++ 规定，一个表达式中相邻的两个操作符的计算次序为：优先级高的先计算；如果优先级相同，则自左向右计算；当使用括号时，从最内层的括号开始计算。...
C语言--编写函数：计算以下表达式的值，要求在主函数中输入x的值，并输出结果。y=x²-2x+1(x＜0)，y=x³+x+3(x＜=0)
Ccyj_的博客
03-21 850
C语言，函数
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值