手写栈和队列实现计算器

最新推荐文章于 2022-09-06 09:33:18 发布
最新推荐文章于 2022-09-06 09:33:18 发布
阅读量517 收藏 1
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40493829/article/details/104845150
版权

 要求

字符串读入，含义+，-，*,/,(,)
数据含小数

思路

字符串截取读入（数字位数可能不为一位）
template简化代码复杂度
enum增加代码可读性
class 抽象出栈
 ~~~~namespace定义域~~好玩~~


main函数

#include <bits/stdc++.h>

#define stack

#define rep(i,a,b) for(int i=a;i<=b;i++)

std::string s;
#ifdef queue
#include "queue.hpp"
#endif

#ifdef stack
#include "stack.hpp"
My_stack::Stack <double> q1;
My_stack::Stack <char> q2;
#endif

void work()
{
        char c2;
        q2.get_top(c2);q2.pop();
        double a1,a2;
        q1.get_top(a1);q1.pop();
        q1.get_top(a2);q1.pop();
        std::cout<<c2<<" "<<a1<<" "<<a2<<'\n';
       // std::cout<<a1+a2;
        if(c2=='+') q1.push(a1+a2);
        else if(c2=='-')
        {
                q1.push(a2-a1);
        }
        else if(c2=='/')
        {
                q1.push(a2/a1);
        }
        else if(c2=='*')
        {
                q1.push(a1*a2);
        }
}

int main()
{
        #ifdef stack
        
        std::cin>>s;
        rep(i,0,s.length()-1)
        {
                if(s[i]<='9'&&s[i]>='0') 
                {
                        int id1=0;
                        rep(j,i,s.length()-1)
                        {
                                if(s[j]=='/'||s[j]=='*'||s[j]=='+'||s[j]=='-')
                                {
                                        id1=j;break;
                                }
                        }
                        if(!id1) id1=s.length()-1;
                        std::string s2=s.substr(i,id1-i);
                        std::cout<<s2<<'\n';
                        char s_2[50]={0};
                        rep(j,0,s2.length()-1)
                        {
                                s_2[j]=s2[j];
                        }
                        i=id1-1;
                        double ans=atof(s_2);
                        q1.push(ans);
                }
                else if(s[i]=='+'||s[i]=='-')
                {	//std::cout<<"dwq";
                        while(!q2.empty()&&(q2.top()=='+'||q2.top()=='-'||q2.top()=='*'||q2.top()=='/'))
                        {
                        	
                                        work();
                        }
                        q2.push(s[i]);
                }
                else if(s[i]=='*'||s[i]=='/')
                {
                        while(!q2.empty()&&(q2.top()=='*'||q2.top()=='/'))
                        {
                                work();
                        }
                        q2.push(s[i]);
                }
                else if(s[i]=='(') q2.push(s[i]);
                else if(s[i]==')')
                {
                        while(q2.top()!='(')
                        {
                                work();
                        }
                        q2.pop();
                }
        }
        while(!q2.empty())
        {
        	work();
        }
        double ans=0;
        q1.get_top(ans);
        std::cout<<ans<<'\n';
        #endif
        #ifdef queue
        My_queue::Queue <int> q;
        rep(i,1,5) q.push(i);
        rep(i,1,2) q.pop();
        rep(i,6,8) q.push(i);
        rep(i,1,1) q.pop();
        int n;
        q.get_front(n);
        std::cout<<n<<'\n';
        #endif
        return 0;
}

//stack.cpp

#include <iostream>

enum error_code {success,overflow,underflow};

namespace My_stack
{
        template<class T>
        class Stack
        {
        public:
        Stack();
        ~Stack();
        bool empty() const;
        bool full() const;
        error_code get_top(T &a) const;
        error_code push(T a) ;
        double top() ;
        error_code pop() ;
        
        private:
        T* my_date;
        int max_size;
        int cnt;
        };
        
        template <class T> Stack<T>::Stack()
        {
                this->max_size=10000;
                this->cnt=0;
                my_date = new T [max_size];
        }
        template <class T> Stack<T>::~Stack()
        {
                delete my_date;
        }
        template <class T> bool Stack<T>::full() const
        {
                if(this->cnt==this->max_size) return 1;
                else return 0;
        }
        template <class T> bool Stack<T>::empty() const
        {
                if(this->cnt==0) return 1;
                else return 0;
        }
        template <class T> error_code Stack<T>::get_top(T &a) const
        {
                if(this->empty()) return underflow;
                else 
                {
                        a = my_date[cnt-1];
                        return success;
                }        
        }
        template <class T>  double Stack<T>::top() 
        {
                if(!empty()) return my_date[cnt-1];
        }
        template <class T> error_code Stack<T>::push(T a) 
        {
                if(full()) return overflow;
                else 
                {
                my_date[cnt]=a;
                cnt++;
                //std::cout<<cnt<<'\n';
                return success;
                }
        }
        template <class T> error_code Stack<T>::pop() 
        {
                if(this->empty()) return overflow;
                else 
                {
                        my_date[cnt-1]=0;
                        --cnt;
                        return success;
                }
        }
}

//附赠queue抽象

#include <iostream>

enum error_code {success,overflow,underflow};

const int max_size=1000;

namespace My_queue
{
        template<class T>
        class Queue
        {
        public:
        Queue();
        ~Queue();
        bool empty() const;
        bool full() const;
        error_code get_front(T &a) const;
        error_code push(T a) ;
        error_code pop() ;
        private:
        T* my_date;
        int cnt;
        int left;
        int right;
        };
        
        template <class T> Queue<T>::Queue()
        {
                this->cnt=0;
                this->left=this->right=0;
                my_date = new T [max_size];
        }
        template <class T> Queue<T>::~Queue()
        {
                delete my_date;
        }
        template <class T> bool Queue<T>::full() const
        {
                if(this->cnt==max_size) return 1;
                else return 0;
        }
        template <class T> bool Queue<T>::empty() const
        {
                if(this->cnt==0) return 1;
                else return 0;
        }
        template <class T> error_code Queue<T>::get_front(T &a) const
        {
                if(this->empty()) return underflow;
                else 
                {
                        a = my_date[(left+1)%max_size];
                        return success;
                }        
        }
        template <class T> error_code Queue<T>::push(T a) 
        {
                if(full()) return overflow;
                else 
                {
                right=(++right)%max_size;
                my_date[right]=a;
                cnt++;
                //std::cout<<cnt<<'\n';
                return success;
                }
        }
        template <class T> error_code Queue<T>::pop() 
        {
                if(this->empty()) return overflow;
                else 
                {
                        left=(left+1)%max_size;
                        //y_date[left]=0;
                        --cnt;
                        return success;
                }
        }
}

 

此后无良辰
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【算法笔记】使用栈(stack)和队列(queue)完成的一个简单计算器(同时求解后缀表达式)
Henry爱学习
02-18 460
题目描述 读入一个只包含加减乘除的非负整数计算表达式，并求解结果； 本题用来练习栈和队列的使用，核心是中缀表达式转后缀表达式； 输入格式 每次输入一行，整数和运算符之间用一个空格(或者可以不加)分隔； 输出格式 每次输出一行，精确到小数点后 2 位； 输入示例 30 / 90 - 26 + 97 - 5 - 6 - 13 / 88 * 6 + 51 / 29 + 79 * 87 + 57 * 92...
【算法笔记】栈/队列 的应用-（codeup 1918）简单计算器
null
04-17 1182
栈/队列 的应用-（codeup 1918）简单计算器栈栈的常见操作队列队列常见操作【codeup 1918】 简单计算器 栈 栈：后进先出的数据结构。 栈顶指针：始终指向栈的最上方元素的一个标记。使用数组实现栈时，栈顶指针是一个int型变量（数组下标从零开始），记top；使用链表实现栈时，是一个int* 型指针。 栈中没有元素，栈空时令top为-1。 栈的常见操作 清空 clear() 栈顶指针置为-1 void clear(){ TOP=-1; } 获取栈内元素个数 size() top指针始
简易计算器（栈与队列的使用）
lovingchq的博客
02-17 841
题目描述 读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。 输入 测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。 输出 对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。 样例输入 30 / 90 - 26 + 97 - 5 - 6 - 13...
bit栈与队列实现计算器
06-10
用栈与对列实现简易的计算器功能，用于专题程序。编写程序，要求可对一实数算术表达式进行简单的数学运算。 可以识别带加减乘除等运算符及括号的中缀表达式。 a. 按照四则运算规则，求表达式的值。一般规则如下： 1）先括号内，再括号外。 2）先乘方，再乘除，后加减。 b. 同级运算从左到右顺序执行。 c．如表达式有误，应给出相应的提示信息。
利用堆栈和队列实现计算器
yyb0802的博客
10-30 2805
我们为了简化代码量所以使用stack和queue两个stl库中所提供的函数，所有的函数实现全部和前面所提供的一致 map是一个函数映射库，普通的数组可以看成是int型到int，char等其他类型的映射，而我们可以用map实现char到int的映射，从而实现优先级的定义 思路如下： 需要先将中缀表达式转化为后缀表达式，随后将后缀表达式利用堆栈特性进行计算 定义一个符号堆栈和后缀表达式的计算队
javaScript实现web和app手写签名.html
05-29
js实现手写签名,可以在移动端使用!下载直接打开就可以使用,有保存和重置功能!
c++手写中文输入法MFC实现
11-27
本文将深入探讨如何使用C++和MFC来实现一个手写中文输入法，并在Windows平台上进行嵌入式应用。 首先，我们要理解MFC的工作原理。MFC封装了Windows API，提供了窗口、控件、消息处理等基础元素的类，使得开发者可以...
Android编程实现的手写板和涂鸦功能
08-28
"Android编程实现的手写板和涂鸦功能" Android编程实现的手写板和涂鸦功能是Android开发中一个常见的功能模块，它涉及到Android界面布局、图形绘制、事件处理等多方面的技术。下面我们将对该功能的实现技术进行详细...
基于opencv和深度学习的手写计算器python源码+文档介绍.zip
最新发布
05-09
基于opencv和深度学习的手写计算器python源码+文档介绍.zip本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有...
c++手写队列头文件.h
11-02
c++手写队列头文件,STL有的都有 还额外支持[]访问下标
栈与队列完成简易计算器报告
06-10
问题描述 通过模拟一个简单的计算器来进行+、-、*、/、%、^（乘方）等运算，从键盘上输入一个算术表达式（一般为中缀表达式），计算出表达式的值。 设计要求 编写程序，要求可对一实数算术表达式进行简单的数学运算。 可以识别带加减乘除等运算符及括号的中缀表达式。 a. 按照四则运算规则，求表达式的值。一般规则如下： 1）先括号内，再括号外。 2）先乘方，再乘除，后加减。 b. 同级运算从左到右顺序执行。 c．如表达式有误，应给出相应的提示信息
利用栈和队列实现的计算器的C语言
01-08
利用栈和队列实现的计算器的C语言 通过测试
递归和队列实现基本计算器
yaogepila的博客
05-31 472
题目： 实现一个基本的计算器来计算一个简单的字符串表达式的值。 字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。 LeetCode：https://leetcode-cn.com/problems/basic-calculator-ii/ 思路 先不考虑空格，以及乘除、括号，假设现在有一个最简单的表达式，只有加减两种运算符，也没有括号，应该如何运算？ 显而易见，从左到右，依次遍历即可，那我们先把这样的情况翻译成代码，借助队列，队列中从0位置到最后一个位置，对
hdu1237（简单计算器） LinkedList类实现栈和队列功能
寻找、发现、追求、获得———这就是狼的生活要素
08-14 1186
LinkedList类的强大，既能看做队列，也能看做栈，很好的体现了队列，栈和集合的关系和区别的例题
使用栈实现简单计算器
Little Big Us的博客
10-24 1249
描述： 输入一串字符串，输出它的计算结果。//考虑输入不正确的情况 例如输入：722-5+1-5+3-4 输出18 代码如下： public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str = sc.next(); Stack<Character> stack2 = new Stack<>();
简易计算器 栈队列的应用
XXX
07-20 175
题目描述 读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。 输入 测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。 输出 对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。 样例输入 30 / 90 - 26 + 97 - 5 - 6 - 13 / 88 * 6 + 51 / 29 + 79 * 87 + 57 * 92 0 样例输出
使用栈实现简单的计算器
qq_66387228的博客
09-06 740
使用栈完成计算一个表达式
（DAY5 栈与队列）“计算器”专题问题 学习报告
eliyou的博客
01-31 258
本来打算写一个普普通通的DAY5学习报告，DAY5的总体知识量小但难度不算小，而这个解算式（我称之为计算器问题）则是其中最难的。因此，我就通过简单地解析这一类题，来研究一下队列。 一.解前缀表达式（难度1） 例题1（openjudge 2.2）（难度1）： （此处提示非常有用） 对于计算器问题，一般有两种解法：递归解法和队列解法。我们要先分析一下，这题用递归还是用队列。 首先观察一下这个问题，对于每一个运算符，都要对它下面的两个数进行操作，如果不够两个数，就进行下一组运算凑够两个数。例如这里的样例，就.
堆和队列的应用之——简单计算器
weixin_30580943的博客
10-09 76
#include<stdio.h> #include<cstdio> #include<string> #include<queue> #include<map> #include<stack> #include<iostream> using namespace std; struct nod...
用c语言手写栈实现一个计算器
03-26
#include <stdio.h> #include <stdlib.h> #define MAX_SIZE 100 // 定义栈的最大容量 typedef struct { int top; // 栈顶指针 int* data; // 栈内数据存储数组 } Stack; // 初始化栈 void initStack(Stack* s) { s->data = (int*)malloc(MAX_SIZE * sizeof(int)); // 动态分配内存 s->top = -1; // 初始化栈顶指针 } // 判断栈是否为空 int isEmpty(Stack* s) { return s->top == -1; } // 判断栈是否已满 int isFull(Stack* s) { return s->top == MAX_SIZE - 1; } // 入栈 void push(Stack* s, int x) { if (isFull(s)) { printf("Stack is full.\n"); return; } s->top++; // 栈顶指针加1 s->data[s->top] = x; // 将数据存储到栈顶位置 } // 出栈 int pop(Stack* s) { if (isEmpty(s)) { printf("Stack is empty.\n"); return -1; } int x = s->data[s->top]; // 取出栈顶元素 s->top--; // 栈顶指针减1 return x; } // 获取栈顶元素 int peek(Stack* s) { if (isEmpty(s)) { printf("Stack is empty.\n"); return -1; } return s->data[s->top]; } // 判断字符是否为操作符 int isOperator(char c) { return c == '+' || c == '-' || c == '*' || c == '/'; } // 计算表达式 int calculate(int a, int b, char op) { switch (op) { case '+': return a + b; case '-': return a - b; case '*': return a * b; case '/': return a / b; default: return 0; } } // 计算表达式（后缀表达式） int evaluate(char* postfix) { Stack s; initStack(&s); char* p = postfix; while (*p != '\0') { if (*p >= '0' && *p <= '9') { // 如果是数字，将其入栈 int num = *p - '0'; while (*(p+1) >= '0' && *(p+1) <= '9') { // 处理多位数字 num = num * 10 + *(++p) - '0'; } push(&s, num); } else if (isOperator(*p)) { // 如果是操作符，弹出栈顶的两个数字进行计算 int b = pop(&s); int a = pop(&s); int result = calculate(a, b, *p); push(&s, result); } p++; } return pop(&s); // 最后栈内只剩下一个结果，返回它 } int main() { char infix[100]; // 中缀表达式 printf("Enter an infix expression: "); scanf("%s", infix); // 将中缀表达式转换为后缀表达式 char postfix[100]; // 后缀表达式 Stack s; initStack(&s); char* p = infix; char* q = postfix; while (*p != '\0') { if (*p >= '0' && *p <= '9') { // 如果是数字，直接输出到后缀表达式 *(q++) = *p; } else if (*p == '(') { // 如果是左括号，入栈 push(&s, *p); } else if (*p == ')') { // 如果是右括号，弹出栈内所有操作符并输出到后缀表达式，直到遇到左括号 while (!isEmpty(&s) && peek(&s) != '(') { *(q++) = pop(&s); } pop(&s); // 弹出左括号 } else if (isOperator(*p)) { // 如果是操作符 while (!isEmpty(&s) && peek(&s) != '(' && ((*p == '+' || *p == '-') && (peek(&s) == '*' || peek(&s) == '/'))) { // 如果栈顶有更高优先级的操作符，则弹出栈顶操作符并输出到后缀表达式 *(q++) = pop(&s); } push(&s, *p); // 将当前操作符入栈 } p++; } while (!isEmpty(&s)) { // 将栈内剩余的操作符输出到后缀表达式 *(q++) = pop(&s); } *q = '\0'; // 末尾添加结束符 printf("Postfix expression: %s\n", postfix); int result = evaluate(postfix); printf("Result: %d\n", result); return 0; }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值