简易计算器（核心算法就是Shutting-Yard， 逆波兰式）

最新推荐文章于 2021-04-19 19:43:15 发布
最新推荐文章于 2021-04-19 19:43:15 发布
阅读量764 收藏
点赞数
分类专栏： 数据结构 算法设计训练 文章标签： 逆波兰式 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bleach_kids/article/details/50934953
版权

算法描述

INPUT: 需要解析转换的中缀表达式epr，epr是一个字符串

OUTPUT: 和epr相对应的后缀（逆波兰）表达式（存储在队列Q中）

 

初始化队列Q和符号栈S;

WHILE（epr中还有内容未处理）

读取下一个标记单元（token），记做tk;

IF（tk是数值） 将tk添加到队列Q中;

IF（tk是函数名） 将tk压到栈S中;

IF（tk是函数参数的逗号分隔符‘,’）

WHILE（S栈顶元素不是左括号‘(’)

将S栈顶元素出栈，添加到队列Q中;

IF（S为空) 提示错误信息“逗号分隔符位置有误，或者括号不匹配”，终止;

 

IF（tk是运算符）//不妨将tk对应的运算符记做op1

WHILE（S栈顶元素是运算符）//不妨将栈顶元素对应的运算符记做op2

IF（（op1左结合 AND op1优先级≤op2优先级）OR（op1优先级<op2优先级））

将S栈顶元素出栈，添加到队列Q中;

将tk压到栈S中;

 

IF（tk是左括号‘(’） 将tk压到栈S中;

 

IF（tk是右括号‘）’）

WHILE（S栈顶元素不是左括号‘(’)

将S栈顶元素出栈，添加到队列Q中;

IF（S为空) 提示错误信息“括号不匹配”，终止;

ELSE 将S栈顶元素（即，左括号）出栈;

IF（S栈顶元素是函数名） 将S栈顶元素出栈，添加到队列Q中;

 

WHILE（S非空）

IF（S栈顶元素是括号) 提示错误信息“括号不匹配”，终止;

将S栈顶元素出栈，添加到队列Q中;

 

return 队列Q;

3）算例：3 + 4 * 2 / Pow(Pow(1 - 5, 2),2)

Token

Action

output Queue Q

Operator Stack S

Notes 

3

Add token to output queue

3

 

The most left is front-of-queue/top-of-stack

+

Push token to stack

3

+

 

4

Add token to output queue

3 4

+

 

*

Push token to stack

3 4

* +

'*' has hihger precedence than '+'

2

Add token to output queue

3 4 2

* +

 

/

Pop operator to output queue

3 4 2 *

+

'/' has the same precedence with '*' and is left-associative

Push token to stack

3 4 2 *

/ +

Pow

Push funtion token to stack

3 4 2 *

Pow / +

 

(

Push l-parenthesis to stack

3 4 2 *

( Pow / +

 

Pow

Push funtion token to stack

3 4 2 *

Pow ( Pow / +

 

(

Push l-parenthesis to stack

3 4 2 *

( Pow ( Pow / +

 

1

Add token to output queue

3 4 2 * 1

( Pow ( Pow / +

 

-

Push token to stack

3 4 2 * 1

- ( Pow ( Pow / +

 

5

Add token to output queue

3 4 2 * 1 5

- ( Pow ( Pow / +

 

,

Pop operator to output queue

3 4 2 * 1 5 -

( Pow ( Pow / +

',' is function argument separator,so pop operators off the stack onto the output queue until the token at the top of the stack is a left parenthesis

2

Add token to output queue

3 4 2 * 1 5 - 2

( Pow ( Pow / +

 

)

Remove l-parenthesis from stack

3 4 2 * 1 5 - 2

Pow ( Pow / +

 

Pop function token to output

3 4 2 * 1 5 - 2 Pow

( Pow / +

,

Do nothing

3 4 2 * 1 5 - 2 Pow

( Pow / +

',' is function argument separator,but '(' is at the top of stack

2

Add token to output

3 4 2 * 1 5 - 2 Pow 2

( Pow / +

 

)

Remove l-parenthesis from stack

3 4 2 * 1 5 - 2 Pow 2

Pow / +

 

Pop function token to output

3 4 2 * 1 5 - 2 Pow 2 Pow

/ +

NULL

Pop operator to output

3 4 2 * 1 5 - 2 Pow 2 Pow /

+

No more tokens to read

NULL

Pop operator to output

3 4 2 * 1 5 - 2 Pow 2 Pow / +

 

 

 

 

 

 

 

 

 

 

 


过程应该都能理解吧，不理解的可以留言问我。同时觉得有更好的想法的，可以留言提醒我哦。


个人的源代码如下：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
const int N=100;

double var=0, uar=0, war=0;

/***********************结点结构体**************************/
struct all
{
	char type[5];		//结点的类型:db(double), char, var(变量), han(函数)
	double num;			//装载数字
	char fu;			//装载运算符
	char var[5];		//装载变量
	char han[5];		//装载函数
};

/**************************栈*******************************/
struct stack
{
	all elem[N];	//栈结点
	int len;		//len为长度
};

//初始化栈
void InitStack(stack *&S)
{
	memset(S->elem, 0, sizeof(all)*N);
	S->len=0;
}

//判断栈是否为空
bool EmptyStack(stack *S)
{
	return (S->len==0)?true:false;
}

//结点n进栈
void StackPush(stack *&S, all n)
{
	S->elem[S->len]=n;
	S->len++;
}

//栈顶元素出栈，并将栈顶元素保留在n中，若栈空则返回失败
bool StackPop(stack *&S, all &n)
{
	if(EmptyStack(S)) return false;
	n=S->elem[S->len-1];
	S->len--;
	return true;
}


/**************************队列*******************************/

struct queue
{
	all elem[N];
	int len;
};

//初始化队列
void InitQueue(queue *&Q)
{
	memset(Q->elem, 0, sizeof(all)*N);
	Q->len=0;
}

//判断队列是否为空
bool EmptyQueue(queue *Q)
{
	return (Q->len==0)?true:false;
}

//结点n进队
void QueuePush(queue *&Q, all n)
{
	Q->elem[Q->len]=n;
	Q->len++;
}

//队首元素出队，并将队首元素保存在n中，若队列以空，则返回失败
bool QueuePop(queue *&Q, all &n)
{
	if(EmptyQueue(Q)) return false;
	n=Q->elem[0];
	for(int i=0; i<Q->len-1; i++)
	{
		Q->elem[i]=Q->elem[i+1];
	}
	Q->len--;
	return true;
}

/*****************************ShuttingYard算法***********************************/

//一个返回10的m次方的函数
double power(int m)
{
	int temp=1;
	m--;
	while(m--)
	{
		temp=temp*10;
	}
	return temp;
}

//把数字字符串转化为double型的数字
double change(char num[])
{
	int i, j;
	int len=strlen(num);
	double sum=0.0;
	for(i=0; i<len; i++)
	{
		if(num[i] == '.') break;
	}
	if(i == len-1)
	{
		for(j=0; j<i; j++)
		{
			sum+=pow(10, i-j)*(num[i]-'0');
		}
	}
	else
	{	
		for(j=0; j<i; j++)
		{
			sum+=pow(10,i-j-1)*(num[j]-'0');
		}
		for(j=i+1; j<len; j++)
		{	
			sum+=pow(10,(j-i)*(-1))*(num[j]-'0');
		}
	}
	return sum;
}

//中缀表达式转后缀
//思路就是从头开始遍历mid数组，若碰到数字的字符串temp（如：3.14）则将其转换为double型放入队列Q中
//若碰到'+' || '-' || '*' || '/' || 'pow'(一个函数，用来求n的m次方) || 'sqrt'(一个函数，用来求n的开平方) || '='，
//则将其压进符号栈S，若进栈元素为'+' || '-'则先检测栈顶元素的优先级是否大于进栈元素的优先级，若是则将栈顶元素出栈
//把出栈的元素进队列Q中，然后进栈元素再进栈，否则直接让进栈元素进栈
//若碰到')'则让符号栈依次出栈，并将出栈元素依次压进队列中，直到碰到'('或者栈空为止，出栈'('，
//然后再检测栈顶元素是否为函数，若是则将其出栈并压进队列中，否则进入下一轮检测
//最终循环结束，返回队列Q
queue ShuttingYard(char mid[])
{
	int i, j;
	queue *Q=new queue;
	InitQueue(Q);
	stack *S=new stack;
	InitStack(S);
	bool flag = false;
	for(i=0; i<strlen(mid); i++)
	{
		if(mid[i]>='0' && mid[i]<='9')
		{
			char temp[10]={0};
			for(j=i; j<strlen(mid); j++)
			{
				if(mid[j] == '.')
				{
					temp[j-i]=mid[j];
					continue;
				}
				if(mid[j] < '0' || mid[j] > '9')
				{
					i=j-1;
					break;
				}
				temp[j-i]=mid[j];
			}
			all t;
			char db[3]={"db"};
			strcpy(t.type, db);
			t.num=change(temp);
			if(flag == true)
			{	
				t.num=-1*t.num;
				flag = false;
			}
			QueuePush(Q, t);
		}
		else if(mid[i] == '(')
		{
			all t;
			char ch[5]={"char"};
			strcpy(t.type,ch);
			t.fu='(';
			StackPush(S, t);
		}
		else if(mid[i] == ')')
		{
			all t;
			while(!EmptyStack(S) && (StackPop(S, t) && t.fu != '('))
			{
				QueuePush(Q, t);
			}
			if(!EmptyStack(S))
			{
				StackPop(S, t);
				if(t.type[0] == 'p' || t.type[0] == 's')
				{		
					QueuePush(Q, t);
				}
				else
				{
					StackPush(S, t);
				}
			}
		}
		else
		{
			if(mid[i] == '=')
			{
				all t;
				char ch[5]={"char"};
				strcpy(t.type, ch);
				t.fu='=';
				StackPush(S, t);
			}
			if(mid[i] == 'v' || mid[i] == 'u' || mid[i] == 'w')
			{
				int tmp=i;
				char temp[10]={0};
				for(j=i; j < strlen(mid); j++)
				{
					if(mid[j] <'a' || mid[j] > 'z')
					{
						i=j-1;
						break;
					}
					temp[j-i]=mid[j];
				}
				if(tmp==0)
				{
					all t;
					strcpy(t.type, temp);
					strcpy(t.var, temp);
					QueuePush(Q, t);
				}
				else
				{
					all t;
					char db[3]={"db"};
					strcpy(t.type, db);
					if(temp[0] == 'v')
					{
						t.num=var;
					}
					else if(temp[0] == 'u')
					{
						t.num=uar;
					}
					else t.num=war;
					QueuePush(Q, t);
				}
			}
			if(mid[i] == 'p' || mid[i] == 's')
			{
				char temp[10]={0};
				for(j=i; j < strlen(mid); j++)
				{
					if(mid[j] <'a' || mid[j] > 'z')
					{
						i=j-1;
						break;
					}
					temp[j-i]=mid[j];
				}
				all t;
				strcpy(t.type, temp);
				strcpy(t.han, temp);
				StackPush(S, t);
			}
			if(mid[i] == '+' || mid[i] == '-')
			{
				all t;
				if(mid[i] == '-')
				{
					if(mid[i-1] == '=' || mid[i-1] == '(')
					{
						flag = true;
						continue;
					}
				}
				if(S->elem[S->len-1].fu == '*' || S->elem[S->len-1].fu == '/')
				{	
					StackPop(S, t);
					QueuePush(Q, t);
				}
				char ch[5]={"char"};
				strcpy(t.type, ch);
				t.fu=mid[i];
				StackPush(S, t);
			}
			if(mid[i] == '*' || mid[i] == '/')
			{
				all t;
				char ch[5]={"char"};
				strcpy(t.type, ch);
				t.fu=mid[i];
				StackPush(S, t);
			}
		}
	}
	while(!EmptyStack(S))
	{
		all t;
		StackPop(S, t);
		QueuePush(Q, t);	
	}
	return *Q;
}

/********************************通过返回的Q队列求结果*********************************/

//通过后缀表达式队列Q来求得整个算式的结果
//思路是这样的，先依次遍历队列的元素，检测元素的类型
//若为char类型，则为四则运算符和等于号，若为四则运算符则把（设当前为第i个元素）第i个，第i-1个，第i-2个元素出队列
//把第i-1个元素和第i-2个元素运算结果放回第i-2元素的位置中，此时，队列长度-2，当前指针-2，继续遍历，若为等于号
//则将第i个，第i-1个，第1个元素出队列，把第i-1个元素的数值（sum值）放到第i-2个元素中，第i-2个元素进回原来的队伍位置
//此时队列长度-2，当前指针-2
//若为han类型，则为函数运算符，若为pow(n, m)则把（设当前为第i个元素）第i个，第i-1个，第i-2个元素出队列
//把第i-1个元素和第i-2个元素运算结果放回第i-2元素的位置中，此时，队列长度-2，当前指针-2，继续遍历，
//若为sqrt(n)则把（设当前为第i个元素）第i个，第i-1个元素出队列，把运算结果放回i-1的位置中，此时队列长度-1，当前指针-1，继续遍历
//最终得到结果放到变量中去
void reslut(queue *Q)
{
	int i, j, len=Q->len;
	double sum=0.0;
	all t;
	for(i=0; i<len; i++)
	{
		if(Q->elem[i].type[0] == 'c')
		{			
			if(Q->elem[i].fu == '*')
			{
				char db[3]={"db"};
				strcpy(t.type, db);
				t.num=Q->elem[i-2].num * Q->elem[i-1].num;
				Q->elem[i-2]=t;
				for(j=i-1; j<len; j++)
				{
					Q->elem[j]=Q->elem[j+2];
				}
				len=len-2;
				i=i-2;
			}
			else if(Q->elem[i].fu == '/')
			{
				char db[3]={"db"};
				strcpy(t.type, db);
				t.num=Q->elem[i-2].num / Q->elem[i-1].num;
				Q->elem[i-2]=t;
				for(j=i-1; j<len; j++)
				{
					Q->elem[j]=Q->elem[j+2];
				}
				len=len-2;
				i=i-2;
			}
			else if(Q->elem[i].fu == '-')
			{
				char db[3]={"db"};
				strcpy(t.type, db);
				t.num=Q->elem[i-2].num - Q->elem[i-1].num;
				Q->elem[i-2]=t;
				for(j=i-1; j<len; j++)
				{
					Q->elem[j]=Q->elem[j+2];
				}
				len=len-2;
				i=i-2;
			}
			else if(Q->elem[i].fu == '+')
			{
				char db[3]={"db"};
				strcpy(t.type, db);
				t.num=Q->elem[i-2].num + Q->elem[i-1].num;
				Q->elem[i-2]=t;
				for(j=i-1; j<len; j++)
				{
					Q->elem[j]=Q->elem[j+2];
				}
				len=len-2;
				i=i-2;
			}
			else
			{
				printf("%s\n", Q->elem[0].type);
				if(Q->elem[0].type[0] == 'v')
				{
					var=Q->elem[i-1].num;
				}
				else if(Q->elem[0].type[0] == 'u' )
				{
					uar=Q->elem[i-1].num;
				}
				else war=Q->elem[i-1].num;
				len=len-2;
				i=i-2;
			}
		}
		else 
		{
			if(Q->elem[i].type[0] == 'p')
			{
				char db[3]={"db"};
				strcpy(t.type, db);
				t.num=pow(Q->elem[i-2].num, Q->elem[i-1].num);
				Q->elem[i-2]=t;
				for(j=i-1; j<len; j++)
				{
					Q->elem[j]=Q->elem[j+2];
				}
				len=len-2;
				i=i-2;
			}
			if(Q->elem[i].type[0] == 's')
			{
				char db[3]={"db"};
				strcpy(t.type, db);
				t.num=sqrt((double)Q->elem[i-1].num);
				Q->elem[i-1]=t;
				for(j=i; j<len; j++)
				{
					Q->elem[j]=Q->elem[j+1];
				}
				len=len-1;
				i=i-1;
			}
		}
	}
}

/******************************入口函数main*********************************/
int main()
{
	int cmd;
	char t[N]={0};
	printf("|******************************简易计算器*******************************|\n");
	printf("|     本计算器中设有三个变量(var, uar, war)用来存储结果值和替代常数     |\n");
	printf("|     输入命令 [0](计算) 时,此时需要输入一串算术表达式，格式如下        |\n");	
	printf("|     var=-1+pow(2,3)+sqrt(4)*(-1)/(-2) (注意：字符间不能有空格)        |\n");
	printf("|     输入命令 [1](查询变量值) 时,就会显示3个变量各自的值               |\n");
	printf("|     输入命令 [2](变量值清零) 时,则三个变量值全部清0                   |\n");
	printf("|     输入命令 [3](退出)时,则退出计算器                                 |\n");
	printf("|***********************************************************************|\n");
	while(printf("请输入命令：\n") && scanf("%d", &cmd))
	{
		if(cmd==0)
		{
			memset(t, 0, sizeof(t));
			printf("请输入一个算术表达式,格式如:var=-1+pow(2,3)+sqrt(4)*(-1)/(-2) (注意：字符间不能有空格)\n");
			scanf("%s", t);
			queue q=ShuttingYard(t);
			reslut(&q);
			system("CLS");
		}
		else if(cmd == 1)
		{
			printf("var=%lf\nuar=%lf\nwar=%lf\n", var, uar, war);
		}
		else if(cmd == 2)
		{
			var=uar=war=0.0;
			system("CLS");
		}
		else if(cmd == 3)
		{
			break;
		}
		printf("|******************************简易计算器*******************************|\n");
		printf("|     本计算器中设有三个变量(var, uar, war)用来存储结果值和替代常数     |\n");
		printf("|     输入命令 [0](计算) 时,此时需要输入一串算术表达式，格式如下        |\n");	
		printf("|     var=-1+pow(2,3)+sqrt(4)*(-1)/(-2) (注意：字符间不能有空格)        |\n");
		printf("|     输入命令 [1](查询变量值) 时,就会显示3个变量各自的值               |\n");
		printf("|     输入命令 [2](变量值清零) 时,则三个变量值全部清0                   |\n");
		printf("|     输入命令 [3](退出)时,则退出计算器                                 |\n");
		printf("|***********************************************************************|\n");
	}
	return 0;
}


Tchaikovsky_
关注
专栏目录
NPI (Neural Program Interpreter) 逆波兰表达式--什么是逆波兰表达式
SUZOOSUGAR
06-12 608
之前写在头条上的， 不过头条文本编辑器太难用为了版面，删减了点内容。这里发一下全一些的，有一说一csdn的markdown编辑器确实很好用。 中置表达式与逆波兰 “先算乘除，再算加减，最先算括号”，这是数学老师告诉我们的用来解决表达式的口诀，可以解决最符合我们人类使用习惯的中置表达式(infix expression)：二元运算符会放置在两个运算数之间。 1+1 用来表达1与1的和， 稍微复杂点的例子比如：(A+B*C+D)*E 我们没有任何违和的就可以翻译这则表达式的含义是因为我们强大的大脑和数学.
冒泡排序算法---代码图形化详解以及优化
QingFeng-Li的博客
04-04 2147
很长时间没有写博客了，这段时间迎接了我的下一代宝贝，是人生中很幸福的一件事。今天我给大家介绍一下冒泡排序算法吧。不论哪种语言，在介绍到数组和循环的时候都会说到冒泡排序，并不是它的名字好听而是冒泡排序算法是思路最简单，最容易理解的，那么我们还是通过这个冒泡排序来开启我们算法的排序之路吧。 1 最简单的排序实现 冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的值，如果...
简单LISP算术表达式计算器
07-04
设计一个简单的 LISP 算术表达式计算器。简单 LISP 算术表达式定义如下:(1) 一个0..9的整数；或者(2)(运算符 表达式 表达式)。例如,6,(+45),(+(+25)8) 都是表达式,其值分别为6,9和15。
简单计算器（逆波兰表达式)
热门推荐
qq_41866334的博客
04-19 3万+
简单计算器（逆波兰表达式) for LeetCode 逆波兰表达式求值 , 基本计算器, 基本计算器II 之前其实在编译原理课上用lex写过一个计算器的小作业，但是对于计算器的universal的实现依然是一知半解，因此就借着做LeetCode自己写了一个比较通用的版本。 我们在离散数学中学过后缀表示法，也叫逆波兰表示法(Reverse Polish notation)。计算机可以很轻松的算出逆波兰表示法下的算式，这也是逆波兰表达式求值这题要求我们写的东西。因此，写一个支持加减乘除括号等操作的简单运算器，最
逆波兰表达式实现简单计算器功能
justLym的博客
02-28 1171
问题概述 我们完成一个逆波兰计算器，要求完成如下任务 输入一个中缀表达式，转成后缀表达式（逆波兰表达式），使用stack计算结果 要求支持小括号，和多位整数，我们暂时不考虑小数问题 逆波兰表达式书写 逆波兰表达式（Reverse Polish notation, RPN,或逆波兰记法），也叫后缀表达式，运算符写在数值的后面 为什么要使用逆波兰表达式呢 实现逆波兰表达式其实并不是很难，但是为什么...
计算器核心算法(一)
小金子的专栏
11-12 1万+
实现了计算器的核心功能,递归算法,带领大家一步一步的实现等式的混合运算
计算器核心解析算法
洋葱汪的博客
07-13 1817
1、计算器核心算法 1. 将中缀表达式进行数字和运算符的分离 2. 将中缀表达式转换为后缀表达式 3. 通过后缀表达式计算最终结果 2、分离算法思想 初始num变量为空，遍历字符串每个字符（用字符串表示数字） 若遇到数字或小数点，累加到num变量，并用p...
Rust中 Shutting-yard算法的示例实现_rust_代码_下载
06-11
在 Rust中 Edsger Dijkstra 的Shutting-yard 算法的示例实现。 此实现处理： 二进制+, -, *, /, 和^（指数）运算符 一元+和-运算符 括号 关联性（大多数运算符左侧，取幂右侧） 分流 Rust 包括一个基于正则表达式...
eureka-client无法启动com.netflix.discovery.DiscoveryClient : Shutting down DiscoveryClient
泽宇的博客
07-03 1万+
解决方法： 在pom.xml中加入或者父pom.xml中加入 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> ...
RuoYi-activitiRuoYi-activitiRuoYi-activiti
06-24
1. Activiti核心概念：Activiti是基于BPMN 2.0标准的工作流引擎，支持流程定义、流程实例、任务、事件等多种核心概念。BPMN 2.0是一种图形化的业务流程建模语言，使得非技术人员也能理解流程模型。 2. 流程定义...
简单的LISP算术表达式计算器
06-27
一个mfc界面的 一个c的 以及本人做的一个简单lisp表达式计算器带课程设计报告 一个网上搜到的代码
简单LISP算术表达式计算器源代码
06-12
这是严蔚敏的数据结构习题集中实习题4.4简单LISP算术表述式计算器的源代码
ShuntingYard:Shunting Yard算法的快速实现
03-20
Shunting Yard算法的快速实现。 使用调度场算法使用书面convert表达式到（又称逆波兰式，或RPN）。 例子： 缀：2 / 8-3 *（15/5）后缀：2 8/3 15 5 / *- 还评估表达式。 表达式：2 / 8-3 *（15/5）中缀令牌：[2，/，8，-，3，*，（，15，/，5，）后缀令牌：[2、8，/，3、15、5，/，*，-]结果：-8.75 此处的更多信息： : PEMDAS支持 括弧 指数和根 乘法 分配 添加 减法 目前的局限性 仅将整数作为输入处理 错误处理极少 但是，这应该是微不足道的。 PR：欢迎。 技术细节 使用堆栈和队列来实现，以保持与原始算法的距离。 100％的测试覆盖率，因为为什么不这样。 :smiling_face_with_sunglasses:
Java中的计算器算法
weixiaokang的专栏
11-05 4401
最近，在数据结构课上学习到了后缀表达式。于是决定重写之前做过的计算器APP的算法。（检测表达式合法性的是另外的算法，这里暂时不提及）首先我简单地对比这两种算法： 一、中缀表达式。 1.同时在两边遍历表达式，储存最里层的括号的位置a,b，和括号的对数n。 2.将表达式按括号的位置裁剪出一个子表达,substring(a+1, b)。 3.遍历子表达式，就将从开始位置0到运算符位置k剪切下来就
自己用纯C写的一个简单的表达式科学计算器，欢迎大家观阅。
HaQiaME的博客
10-01 2002
//完美~ #include "stdio.h" #include "string.h" #include "ctype.h" #include "math.h" #define DIGIT 0 //操作数 #define OPERATION 1 //操作符 #define END -1 //结束 #define MAX 1000 #define SIN 115
C语言入门 模拟简单的计算器
06-09
利用C语言来模拟简单的计算器，用户从键盘输入算术表达式，程序在屏幕上输出答案
Shutting down NameNode at zxy-vm/192.168.199.129
最新发布
07-11
抱歉，我是一个AI助手，并不能执行实际的操作。但是，如果你想关闭Hadoop集群中的NameNode节点，你可以使用以下命令： ``` hadoop-daemon.sh stop namenode ``` 这将停止运行在指定节点上的NameNode服务。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值