使用栈实现表达式求值（栈实现计算器），不含语法检测

最新推荐文章于 2024-10-17 09:17:09 发布
最新推荐文章于 2024-10-17 09:17:09 发布
阅读量87 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42481422/article/details/119026610
版权 
/*
这是一个算术表达式求值得源代码
算符间的优先关系：
————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
运算符1\运算符2|    +   |   -   |   *   |   /   |   (   |   )   |    #/=    |
    +         |    >   |   >   |   <   |   <   |   <   |   >   |    >      |
    -         |    >   |   >   |   <   |   <   |   <   |   >   |    >      |
    *         |    >   |   >   |   >   |   >   |   <   |   >   |    >      |
    /         |    >   |   >   |   >   |   >   |   <   |   >   |    >      |
    (         |    <   |   <   |   <   |   <   |   <   |   =   |           |                                                                                                                                                                                                                                                                                 
    )         |    >   |   >   |   >   |   >   |       |   >   |    >      |
    #/=       |    <   |   <   |   <   |   <   |   <   |       |    =      |  
*/
#include"stack"
using namespace std;
char OP[7] = {'+', '-', '*', '/', '(', ')', '#'};
char PMATRIX[7][7] = {
//  {'+', '-', '*', '/', '(', ')', '#'};
    {'>', '>', '<', '<', '<', '>', '>'},
    {'>', '>', '<', '<', '<', '>', '>'},
    {'>', '>', '>', '>', '<', '>', '>'},
    {'>', '>', '>', '>', '<', '>', '>'},
    {'<', '<', '<', '<', '<', '=', ' '},
    {'>', '>', '>', '>', ' ', '>', '>'},
    {'<', '<', '<', '<', '<', ' ', '='}
};

BOOL In(char c, char OP[]){
    for (int i = 0; i < 7; ++i){
        if (c == OP[i]){
            return True;
        }
    }
    return False;
}

char Precede(ElementType_c topelement, char c){
    int i = 0, j = 0;
    for (i = 0; i < 7; ++i){
        if (topelement == OP[i]){
            break;
        }
    }
    for (j = 0; j < 7; ++j){
        if (c == OP[j]){
            break;
        }
    }
    return PMATRIX[i][j];
}

ElementType_f Operate(ElementType_f opnd_1, ElementType_c theta, ElementType_f opnd_2){
    switch (theta){
        case '+':
            return opnd_1 + opnd_2;
            break;
        case '-':
            return opnd_1 - opnd_2;
            break;
        case '*':
            return opnd_1 * opnd_2;
            break;
        case '/':
            return opnd_1 / opnd_2;
            break;        
        default:
            break;
    }
    return 0;
}

ElementType_f sTof(char *c){
    char str[11] = {};  // 最大十位数字
    int i = 1;
    str[0] = *c;
    while(In(*c = getchar(), OP) == False){
        str[i] = *c;
        ++i; 
    }
    str[i] = '\0';
    return atof(str);
}
int main(){
    Stack_c *OPTR = NULL;
    Stack_f *OPND = NULL;  // OPTR运算符栈，OPND运算数栈
    InitStack(&OPTR);
    InitStack(&OPND);
    Push(OPTR, '#');
    char c;
    printf("please input expression:\n");
    c = getchar();
    ElementType_c topelement = {}, popelement = {};
    ElementType_c theta = {};
    ElementType_f opnd_1 = 0, opnd_2 = 0, result = 0;
    GetTop(OPTR, &topelement);
    while (c != '#' || topelement != '#'){
        if (In(c, OP) == False){
            Push(OPND, sTof(&c));
            GetTop(OPTR, &topelement);
            continue;
        }
        else{
            switch (Precede(topelement, c)){
                case '<':  //栈顶元素优先权小于c
                    Push(OPTR, c);
                    c = getchar();
                    GetTop(OPTR, &topelement);
                    break;
                case '=':
                    Pop(OPTR, &popelement);
                    c = getchar();
                    GetTop(OPTR, &topelement);
                    break;
                case '>':
                    Pop(OPTR, &theta);
                    Pop(OPND, &opnd_2);
                    Pop(OPND, &opnd_1);
                    result = Operate(opnd_1, theta, opnd_2);
                    Push(OPND, result);
                    GetTop(OPTR, &topelement);
                    break;
            GetTop(OPTR, &topelement);
            }
        }
    }
    Pop(OPND, &result);
    printf("%f", result);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef char ElementType_c;
typedef double ElementType_f;
typedef enum{True = 0, False = 1} BOOL;

#define DEFAULT_STACKSIZE 100
#define STACKSIZE_INCREMENT 20
typedef struct Stack_c{
    ElementType_c *stack;      // 栈底指针
    ElementType_c *topelement; // 栈顶指针
    int stackSize;
} Stack_c;

typedef struct Stack_f{
    ElementType_f *stack;      // 栈底指针
    ElementType_f *topelement; // 栈顶指针
    int stackSize;
} Stack_f;

BOOL InitStack(Stack_c** stack){
    *stack = (Stack_c *)malloc(sizeof(Stack_c));
    if (stack == NULL){
        return False;
    }
    else{
        (*stack)->stackSize = DEFAULT_STACKSIZE; // 栈的大小为DEFAULT_STACKSIZE
        // 将栈的空间stack分配好
        ElementType_c *stack_;
        stack_ = (ElementType_c *)malloc(sizeof(ElementType_c) * ((*stack)->stackSize));
        if (stack_ == NULL){
            return False;
        }
        else{
            memset(stack_, 0, sizeof(stack_));
            (*stack)->stack = stack_;
            (*stack)->topelement = stack_;
            // *(*stack)->topelement = '\0';  // 将栈转为字符串
            return True;
        }
    }
} // 操作结果：构造一个空栈stack
BOOL InitStack(Stack_f** stack){
    *stack = (Stack_f *)malloc(sizeof(Stack_f));
    if (stack == NULL){
        return False;
    }
    else{
        (*stack)->stackSize = DEFAULT_STACKSIZE; // 栈的大小为DEFAULT_STACKSIZE
        // 将栈的空间stack分配好
        ElementType_f *stack_;
        stack_ = (ElementType_f *)malloc(sizeof(ElementType_f) * ((*stack)->stackSize));
        if (stack_ == NULL){
            return False;
        }
        else{
            memset(stack_, 0, sizeof(stack_));
            (*stack)->stack = stack_;
            (*stack)->topelement = stack_;
            // *(*stack)->topelement = '\0';  // 将栈转为字符串
            return True;
        }
    }
} // 操作结果：构造一个空栈stack
// 初始条件：栈S已存在
BOOL DestroyStack(Stack_c *stack){
    if (stack == NULL){
        return False;
    }
    else{
        free(stack->stack);
        stack->stack = NULL;
        free(stack);
        stack = NULL;
        return True;
    }
} // 操作结果：栈stack被销毁

BOOL DestroyStack(Stack_f *stack){
    if (stack == NULL){
        return False;
    }
    else{
        free(stack->stack);
        stack->stack = NULL;
        free(stack);
        stack = NULL;
        return True;
    }
} // 操作结果：栈stack被销毁

// 初始条件：栈S已存在
BOOL StackEmpty(Stack_c *stack){
    if (stack == NULL){
        return False;
    }
    else{
        if (stack->topelement == stack->stack){
            return True;
        }
        else{
            return False;
        }
    }
} // 操作结果：若栈为空则返回True，否则返回False

BOOL StackEmpty(Stack_f *stack){
    if (stack == NULL){
        return False;
    }
    else{
        if (stack->topelement == stack->stack){
            return True;
        }
        else{
            return False;
        }
    }
} // 操作结果：若栈为空则返回True，否则返回False
// 初始条件：栈S已存在
int StackLength(Stack_c *stack){
    if (stack == NULL){
        return -1;
    }
    else{
        if (StackEmpty(stack) == True){
            return 0;
        }
        else{
            return (int)(stack->topelement - stack->stack);
        }
    }
} // 操作结果：返回S的元素个数，即栈的长度。

int StackLength(Stack_f *stack){
    if (stack == NULL){
        return -1;
    }
    else{
        if (StackEmpty(stack) == True){
            return 0;
        }
        else{
            return (int)(stack->topelement - stack->stack);
        }
    }
} // 操作结果：返回S的元素个数，即栈的长度。

// 初始条件：栈S已存在且非空
BOOL GetTop(Stack_c *stack, ElementType_c *topelement){
    if (stack == NULL){  // 不可能出现的情况 &后接NULL
        return False;
    }
    else{
        if (StackEmpty(stack) == True){
            topelement = NULL;
            return False;
        }
        else{
            ElementType_c *p = stack->topelement - 1;
            *topelement = *p;
            return True;
        }
    }
} // 操作结果：用topelement返回S的栈顶元素

BOOL GetTop(Stack_f *stack, ElementType_f *topelement){
    if (stack == NULL){  // 不可能出现的情况 &后接NULL
        return False;
    }
    else{
        if (StackEmpty(stack) == True){
            topelement = NULL;
            return False;
        }
        else{
            *topelement = *(stack->topelement - 1);
            return True;
        }
    }
} // 操作结果：用topelement返回S的栈顶元素

// 初始条件：栈S已存在
BOOL Push(Stack_c *stack, ElementType_c pushelement){
    if (stack == NULL){
        return False;
    }
    else{
        if (StackLength(stack) >= stack->stackSize){
            stack->stack = (ElementType_c *)realloc(stack->stack, (stack->stackSize + STACKSIZE_INCREMENT) * sizeof(ElementType_c));
            if (stack->stack == NULL){
                return False;
            }
            else{
                stack->stackSize += STACKSIZE_INCREMENT;
            }
        }
        *(stack->topelement) = pushelement;  // 两句合并成一句 *stack->toplement++ =  pushelement
        ++(stack->topelement) ;
        return True;
    }
} // 操作结果：插入元素pushelement为新的栈顶元素

BOOL Push(Stack_f *stack, ElementType_f pushelement){
    if (stack == NULL){
        return False;
    }
    else{
        if (StackLength(stack) >= stack->stackSize){
            stack->stack = (ElementType_f *)realloc(stack->stack, (stack->stackSize + STACKSIZE_INCREMENT) * sizeof(ElementType_f));
            if (stack->stack == NULL){
                return False;
            }
            else{
                stack->stackSize += STACKSIZE_INCREMENT;
            }
        }
        *(stack->topelement) = pushelement;  // 两句合并成一句 *stack->toplement++ =  pushelement
        ++(stack->topelement);
        return True;
    }
} // 操作结果：插入元素pushelement为新的栈顶元素
// 初始条件：栈S已存在且非空
BOOL Pop(Stack_c *stack, ElementType_c *popelement){
    if (stack == NULL){
        return False;
    }
    else{
        if (StackLength(stack) == 0){
            return False;
        }
        else{
            *popelement = *(--(stack->topelement));
            return True;
        }
    }
} // 操作结果：删除S的栈顶元素，并用e返回其值
BOOL Pop(Stack_f *stack, ElementType_f *popelement){
    if (stack == NULL){
        return False;
    }
    else{
        if (StackLength(stack) == 0){
            return False;
        }
        else{
            *popelement = *(--(stack->topelement));
            return True;
        }
    }
} // 操作结果：删除S的栈顶元素，并用e返回其值

运行结果：
在这里插入图片描述

实现两种数据类型的栈我使用的是函数重载，各位老大哥有什么好的意见多在评论区分享，感激不尽。
参考：《数据结构(C语言版)》清华大学出版社，页44-54。

Mcliar
关注
利用栈计算表达式的值
acm_JL的博客
04-01 1万+
假设算术表达式只包含”+”、“-”、“*”、“/”、正整数和括号的合法数学表达式，求算术表达式值。 过程是：先将算术表达式转换成后缀表达式(逆波兰式)，然后对该后缀表达式求值。 　　1)将算术表达式exp转换成后缀表达式postexp; 　　2)对后缀表达式postexp求值。 中缀表达式a*b+c变成后缀表达式是ab*c+ （1）中缀表达式转换成后缀表达式： a
使用栈实现表达式求值
热门推荐
BestFSQ的博客
02-19 4万+
任何一个表达式都是由操作数，运算符，界限符组成的。操作数即是参加运算的数值或者变量，运算符则是加减乘除等组成，为简单起见，这里只实现加减乘除的运算，而常见的界限符则是左右括号和终止符。在运算过程中，要判断两个先后出现的运算符之间的优先顺序。 为了实现算法，设置两个工作栈：用于存储运算符的栈opter，以及用于存储操作数及中间结果的栈opval。 算法基本思想如下： （1）首先将操作数栈opv
java堆栈四则运算_Java实现四则运算,使用堆栈,检查语法
weixin_42110070的博客
02-19 200
1 importjava.util.HashMap;2 importjava.util.Map;3 importjava.util.Stack;45 public classFunctionStack {67 private MapoptLevel;8 private boolean nextIsOpt = false;9 private boolean debug = f...
数据结构实验——用栈实现表达式的计算（C语言）
i6223671的博客
01-31 1万+
1.实验内容 设计一个程序，演示用算符优先法对算术表达式求值的过程。以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。 2.实验思路 算法： 3.代码（配套教材严蔚敏版） #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #define...
通过栈Stack实现括号匹配的语法检查
weixin_33950757的博客
04-07 703
算法的设计思想： 出现左括弧则进栈； 出现右括弧则首先检测栈是否为空， 若栈空则表明此右括弧多余，表达式不匹配。 否则和栈顶数据比较，若匹配则栈顶出栈。 否则表明表达式不匹配； 最后若栈空且没有做鱼右括弧则匹配正确，否则表明不匹配。 ...
表达式求值【C语言实现】数据结构实验
lei20172017的博客
05-04 1万+
表达式求值【C语言实现】数据结构实验 实验内容 表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 实验要求 基本要求：以字符序列的形式从键盘输入语法正确的，不含变量的整型表达式。利用教科书表 3.1 给出的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例 3.1 演示在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。 实现提示 1 设置运算符栈和运算数栈辅助分析算符优先关系。 2 在读入表达式的字符序列的同时
表达式求值问题数据结构课程设计
qq_54467680的博客
12-29 6825
(一万字课设)读入原表达式（包括括号）并创建对应二叉树，其次对二叉树进行前序遍历、中序遍历、后续遍历（非递归），并输出逆波兰表达式，最后求解原表达式的值。使用到了栈的基本操作、二叉树的创建（合成树）等。
算术表达式求值的程序设计与实现_数据结构课程设计
qq_58259102的博客
12-28 9514
以下内容可且仅可供参考，如有错误欢迎指正。 部分思路借鉴算术表达式求值（C语言栈）_夜何其的博客-CSDN博客_c语言利用栈求解算术表达式侵删致歉 《算术表达式求值的程序设计与实现》题目要求 1、问题描述 从键盘上输入中缀算术表达式，包括圆括号，计算出表达式的值。 2、设计要求 实现不含变量的整数表达式的算术四则混合运算（＋、－、*和/）。 3、数据结构 本课题代码实现使用的数据结构为顺序栈。 目录 1程序目标及问题分析 1.1问题描述 1.2问题分析 2系统功能设计 ...
算术表达式求值演示（C/C++实现）
WTomster的博客
12-09 2663
算术表达式求值演示 问题描述：表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 基本要求：以字符序列的形式从键盘输入语法正确的，不含变量的整型表达式。利用教科书表3.1给出的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例3.1演示在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。 测试数据：3*(7-2) 1+2+3+4 88-1*5 1024/4*8 1024/(4*8) (20+2)*(6/2) 3-3
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用运算符优先关系，实现对算术四则混合运算表达式的求值。 【测试数据】 （1）能够判断表达式中的括号是否匹配，测试的表达式中括号不匹配，可以...
算数表达式求值演示
10-21
利用下表给出的算符优先关系，实现对算术混合运算表达式的求值，并仿照求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。 （2）扩充运算符集，如增加乘方、单目减、赋值等运算 （3）计算器的功能和仿真界面
算术表达式求值完整课程设计报告-对于基本的算术表达式，以字符序列的形式从终端进行输入，要求语法正确的，不含变量，按照算术运算优先级顺序，实现基本算术表达式的运算过程。
05-16
本课程设计报告主要探讨了如何实现一个简单的算术表达式求值系统，该系统能够处理不含变量的、基于字符序列的算术表达式，并按照运算优先级顺序进行运算。以下是详细的知识点说明： 1. **输入与输出**： - 用户...
算术表达式求值
01-27
能根据输入的表达式求取所得的结果,以字符序列的形式从终端...利用教科书上给出的算符优先关系，实现对算术四则运算表达式的求值，并仿照教科书的例子演示在求值中运算符栈，运算数栈，输入字符和主要操作的变化过程
【数据结构-栈】【贪心】力扣2434. 使用机器人打印字典序最小的字符串
sjsjs11的博客
10-12 390
我们可以思考，将t想象成一个栈，先进后出，然后当栈顶元素的值，也就是t的末尾的值比字符串s中的任何一个字符都要小的时候，那么我们就要将栈顶元素推入p中，也就是写出来的字符串，这样才能保证最小字典序列。，由于0代表a，1代表b…执行第一个操作四次，得到 p=“” ，s=“” ，t=“bdda”。执行第一个操作三次，得到 p=“” ，s=“” ，t=“zza”。执行第一个操作，得到 p=“ab” ，s=“” ，t=“c”。执行第二个操作，得到 p=“abc” ，s=“” ，t=“”。
数据结构-二叉树笔记
2302_80490510的博客
10-14 889
模板题。
数据结构哈夫曼编码-（C语言代码）
2305_78057683的博客
10-11 226
【代码】数据结构哈夫曼编码-（C语言代码）
前端常用算法和数据结构
最新发布
renqq001的博客
10-17 361
前端常用算法和数据结构
数据结构：用双栈实现一个队列
AWSDN的博客
10-11 259
本文主要介绍如何用双栈实现一个队列
数据结构 -- 跳表
分享技术，分享经验
10-11 842
它可以看作是链表与二分查找的结合体，能够在保持数据有序的同时，实现快速的查找，时间复杂度与平衡树（如红黑树）相同，但实现上更为简单。，但是其底层结构需要维护多个层次的节点分裂、合并等复杂操作，特别是在插入和删除时，涉及平衡和重构，带来较高的性能成本。，但其结构更简单，动态操作（如插入、删除、更新）的实现也更加直接，符合 Redis 追求简洁高效的设计理念。删除操作与查找操作类似，从最高层开始查找需要删除的元素，找到元素后，在每一层级的链表中删除该元素的索引。：Redis 的有序集合为什么不使用B+树？
C语言中栈实现表达式求值的详细教程
本文档详细介绍了如何在C语言中使用栈来实现表达式求值，主要针对的是算术四则混合运算，遵循算符优先法则。文章首先阐述了需求分析，明确了程序的目标：接收输入的算术表达式，如 "2*(3+4)"，并输出计算结果，即 "2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值