c语言，中缀表达式转后缀表达式并计算
一、中缀表达式转后缀表达式并计算，后缀表达式字符串形式，数字限定小于10，利用数字栈操作符栈
/* c语言的中缀表达式转后缀表达式并计算结果
中缀表达式含双目运算符和小括号,数字操作数小于10,
演示转变及计算过程
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h> /* 操作符栈结构体 */
typedef struct{
char data[];
int top;
}stack; /* 数字栈结构体 */
typedef struct{
int data[];
int top;
}nstack; /* 栈操作函数声明 */
int priority(char);
char pop(stack*);
int npop(nstack*);
int ntop(nstack*);
char top(stack*);
void push(stack*,char);
void npush(nstack*,char);
bool isnumber(char);
bool isempty(stack*); int main()
{
int i,j,len,cnt;//字符串下标、长度变量 stack *st=(stack*)malloc(sizeof(stack)); //操作符栈
nstack *nst=(nstack*)malloc(sizeof(nstack));//数字栈
st->top=-; //操作符栈空
nst->top=-; //数字栈空 char str[];//中缀表达式字符串
char out[];//后缀表达式字符串 scanf("%s",str);//读取中缀表达式字符串 cnt=;//后缀表达式字符串下标
len=strlen(str);//读取的中缀表达式字符串长度 /* 1.中缀表达式转后缀表达式 */ //1*(2+3)-4
for(i=;i<len;i++)
{
/* 从字符串读取的字符为数字，插入到后缀表达式字符串 */
if(isnumber(str[i]))
out[cnt++]=str[i];
else
{
/* 读取的非数字字符是左括号 或者 操作符栈为空,
读取的字符压到操作符栈,
然后去判断字符串是否读完 */
if(str[i]=='('||isempty(st))
{
push(st,str[i]);
continue;
}
/* 读取的非数字字符是右括号，判断操作符栈是否为左括号，
不是左括号把栈顶的操作符插入到后缀表达式字符串并弹出
最后把左括号弹出，然后去判断字符串是否读完*/
if(str[i]==')')
{
while(top(st)!='(')
{
out[cnt++]=top(st);
pop(st);
}
pop(st);
continue;
}
/* 操作符栈不空且栈顶元素不是左括号
且栈顶元素的优先级大于等于读取的字符优先级
栈顶的操作符插入到后缀表达式字符串并弹出*/
while(!isempty(st)&&top(st)!='('&& priority(str[i])<=priority(top(st)))
{
out[cnt++]=top(st);
pop(st);
}
/* 操作符栈空了或栈顶元素为左括号或
栈顶元素的优先级小于读取的字符优先级
读取的字符压到操作符栈 */
push(st,str[i]);
}
}
/* 操作数栈不为空依次弹出插入到后缀表达式字符串 */
while(!isempty(st)){
out[cnt++]=top(st);
pop(st);
}
out[cnt]='\0';
/* 打印后缀表达式 */ //1 2 3 + * 4 -
for(i=;i<cnt;++i)
printf("%c ",out[i]);
printf("\n"); /* 2.根据后缀表达式计算 */
for(i=;i<cnt;i++)
{
/* 从后缀表示字符串读字符，是数字压数字栈，
然后判断字符串是否读完 */
if(isnumber(out[i])){
npush(nst,out[i]);
continue;
}else if(out[i]=='+'){//数字栈顶元素加到下面元素并弹出栈顶元素
nst->data[nst->top-]+=ntop(nst);
npop(nst);
}else if(out[i]=='-'){//同理减到下面元素
nst->data[nst->top-]-=ntop(nst);
npop(nst);
}else if(out[i]=='*'){ //同理乘到下面元素并弹出栈顶元素
nst->data[nst->top-]*=ntop(nst);
npop(nst);
}else if(out[i]=='/'){ //同理除到下面元素并弹出栈顶元素
nst->data[nst->top-]/=ntop(nst);
npop(nst);
}else if(out[i]=='^'){//同理幂到下面元素并弹出栈顶元素
nst->data[nst->top-]=pow(nst->data[nst->top-],ntop(nst));
npop(nst);
}
for(j=;j<=nst->top;++j)//一趟后剩余的数字栈遍历打印
printf("%d ",nst->data[j]);
for(j=i+;j<cnt;++j) //一趟后剩余的后缀表达式字符打印
printf("%c ",out[j]);
printf("\n");
}
return ;
}
/* 是否数字函数 */
bool isnumber(char ch){
if(ch>=''&&ch<='')
return true;
else
return false;
}
/* 是否栈空函数 */
bool isempty(stack *s){
if(s->top==-)
return true;
else
return false;
}
/* 压栈函数 */
void push(stack *s,char ch){
s->data[++s->top]=ch;
}
void npush(nstack *s,char ch){
s->data[++s->top]=ch-'';
}
/* 弹栈函数 */
char pop(stack *s){
return s->data[s->top--];
}
int npop(nstack *s){
return s->data[s->top--];
}
/* 操作符优先级函数 */
int priority(char ch){
if(ch=='(')
return ;
if(ch=='+'||ch=='-')
return ;
if(ch=='*'||ch=='/')
return ;
if(ch=='^')
return ;
return ;
}
/* 取栈顶元素函数 */
char top(stack *s){
return s->data[s->top];
}
int ntop(nstack *s){
return s->data[s->top];
}
字符串形式
二、中缀表达式转后缀表达式并计算，后缀表达式结构体数组形式，数字可多位，利用数字栈操作符栈
后缀表达式结构体数组中的联合体既可以存放int类型的数字也可以存放char型操作符，可以判断数组元素的数据类型
/* c语言的中缀表达式转后缀表达式并计算结果
中缀表达式含双目运算符和小括号,数字操作数可以多位,
演示转变及计算过程
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h> /* 操作符栈结构体 */
typedef struct{
char data[];
int top;
}stack; /* 数字栈结构体 */
typedef struct{
int data[];
int top;
}nstack; /* 表达式结构体 */
typedef struct {
short b;//判断类型
union {
int num;
char ch;
}u;
}EXPRESSION; /* 栈操作函数声明 */
int priority(char);
char pop(stack*);
int npop(nstack*);
int ntop(nstack*);
char top(stack*);
void push(stack*,char);
void npush(nstack*,int);//参数int
bool isnumber(char);
bool isempty(stack*); int main()
{
int i,j,len,cnt;//字符串下标、长度变量 stack *st=(stack*)malloc(sizeof(stack)); //操作符栈
nstack *nst=(nstack*)malloc(sizeof(nstack));//数字栈
st->top=-; //操作符栈空
nst->top=-; //数字栈空 char str[];//中缀表达式字符串
EXPRESSION out[];//后缀表达式结构体数组
cnt=;//后缀表达式数组下标
int sum = ;//累加数字 scanf("%s",str);//读取中缀表达式字符串
len=strlen(str);//读取的中缀表达式字符串长度
int flag = ;//是数字标识 /* 1.中缀表达式转后缀表达式(用操作符栈) */
for(i=;i<=len;i++)// 100*(2+3)-4 100 2 3 + * 4 -
{
/* 从字符串读取的字符为数字，插入到后缀表达式结构体数组 */
if(isnumber(str[i])&&i<=len){
sum = sum* + str[i] - '';//累加数字
flag = ;//是数字标识
continue;
}
/* 数字进后缀表达式结构体数组的数字 */
if(flag)
{
out[cnt].b = ;
out[cnt++].u.num = sum;
flag = ;
sum = ;
}
/* 读取的非数字字符是左括号 或者 操作符栈为空,
读取的字符压到操作符栈,
然后去判断字符串是否读完 */
if(str[i]=='('||isempty(st))
{
push(st,str[i]);
continue;
}
/* 读取的非数字字符是右括号，判断操作符栈是否为左括号，
不是左括号把栈顶的操作符插入到后缀表达式数组并弹出
最后把左括号弹出，然后去判断字符串是否读完*/
if(str[i]==')')
{
while(top(st)!='(')
{
out[cnt].b = ;
out[cnt].u.ch=top(st); //操作符进后缀表达式数组的字符
cnt++;
pop(st);
}
pop(st);
continue;
}
/* 操作符栈不空且栈顶元素不是左括号
且栈顶元素的优先级大于等于读取的字符优先级
栈顶的操作符插入到后缀表达式数组并弹出*/
while(!isempty(st)&&top(st)!='('&& priority(str[i])<=priority(top(st)))
{
out[cnt].b = ;
out[cnt++].u.ch = top(st);//操作符进后缀表达式数组的字符
pop(st);
}
/* 操作符栈空了或栈顶元素为左括号或
栈顶元素的优先级小于读取的字符优先级
读取的字符压到操作符栈 */
push(st,str[i]);
}
/* 操作符栈不为空依次弹出插入到后缀表达式数组*/
while(!isempty(st)){
out[cnt].b = ;
out[cnt++].u.ch = top(st);//操作符进后缀表达式数组的字符
pop(st);
}
/* 打印后缀表达式 */ //100 2 3 + * 4 - 100*(2+3)-4
for(i=;i<cnt;++i)
{
if(out[i].b==)
printf("%d ",out[i].u.num);
else printf("%c ",out[i].u.ch);
}
printf("\n"); /* 2.根据后缀表达式计算(用操作符栈\数字栈) */
for(i=;i<cnt;i++)
{
/* 从后缀表达式结构体数组读取，是数字压数字栈，
然后判断结构体数组是否读完 */
if(out[i].b == ){
npush(nst,out[i].u.num);
continue;
}
else if(out[i].u.ch=='+'){//数字栈顶元素加到下面元素并弹出栈顶元素
nst->data[nst->top-]+=ntop(nst);
npop(nst);
}else if(out[i].u.ch=='-'){//同理减到下面元素并弹出栈顶元素
nst->data[nst->top-]-=ntop(nst);
npop(nst);
}else if(out[i].u.ch=='*'){ //同理乘到下面元素并弹出栈顶元素
nst->data[nst->top-]*=ntop(nst);
npop(nst);
}else if(out[i].u.ch=='/'){ //同理除到下面元素并弹出栈顶元素
nst->data[nst->top-]/=ntop(nst);
npop(nst);
}else if(out[i].u.ch=='^'){//同理幂到下面元素并弹出栈顶元素
nst->data[nst->top-]=pow(nst->data[nst->top-],ntop(nst));
npop(nst);
} for(j=;j<=nst->top;++j)//一趟后剩余的数字栈遍历打印
printf("%d ",nst->data[j]);
for(j=i+;j<cnt;++j) //一趟后剩余的后缀表达式数字或操作符打印
{
if(out[j].b==)
printf("%d ",out[j].u.num);
else printf("%c ",out[j].u.ch);
}
printf("\n");
}
return ;
}
/* 是否数字函数 */
bool isnumber(char ch){
if(ch>=''&&ch<='')
return true;
else
return false;
}
/* 是否栈空函数 */
bool isempty(stack *s){
if(s->top==-)
return true;
else
return false;
}
/* 压栈函数 */
void push(stack *s,char ch){
s->data[++s->top]=ch;
}
//参数int
void npush(nstack *s,int ch){
s->data[++s->top] = ch;
}
/* 弹栈函数 */
char pop(stack *s){
return s->data[s->top--];
}
int npop(nstack *s){
return s->data[s->top--];
}
/* 操作符优先级函数 */
int priority(char ch){
if(ch=='(')
return ;
if(ch=='+'||ch=='-')
return ;
if(ch=='*'||ch=='/')
return ;
if(ch=='^')
return ;
return ;
}
/* 取栈顶元素函数 */
char top(stack *s){
return s->data[s->top];
}
int ntop(nstack *s){
return s->data[s->top];
}
结构体数组形式
三、中缀表达式转后缀表达式并计算，后缀表达式结构体数组形式，数字可多位，利用数字栈操作符栈
数字栈、操作符栈使用同一结构体，统一接口
/* c语言的中缀表达式转后缀表达式并计算结果
中缀表达式含双目运算符和小括号,数字操作数可以多位,
演示转变及计算过程
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#define N 256 /* 栈结构体 */
typedef struct{
short tag; //判断类型
union{
int* idata;
char* cdata;
}u;
int top;
}stack; /* 表达式结构体 */
typedef struct {
short tag;//判断类型
union {
int num;
char ch;
}u;
}EXPRESSION; /* 栈操作函数声明 */
void push(stack*, int);
int pop(stack*);
int top(stack*);
int priority(char);
bool isnumber(char);
bool isempty(stack*); int main()
{
int i,j,len,cnt;//字符串下标、长度变量 stack istack, cstack;//数字栈 操作符栈 istack.tag = ;
istack.u.idata = (int*)malloc(sizeof(int)*N);
istack.top = -; //操作符栈空 cstack.tag = ;
cstack.u.cdata = (char*)malloc(sizeof(char)*N);
cstack.top = -; //数字栈空 char str[N];//中缀表达式字符串
EXPRESSION out[N];//后缀表达式结构体数组
cnt = ;//后缀表达式数组下标
int sum = ;//累加数字 scanf("%s",str);//读取中缀表达式字符串
len = strlen(str);//读取的中缀表达式字符串长度
int flag = ;//是数字标识 /* 1.中缀表达式转后缀表达式(用操作符栈) */
for(i=; i<=len; i++)// 100*(2+3)-4 100 2 3 + * 4 -
{
/* 从字符串读取的字符为数字，插入到后缀表达式结构体数组 */
if(isnumber(str[i])){
sum = sum* + str[i] - '';//累加数字
flag = ;//是数字标识
continue;
}
/* 数字进后缀表达式结构体数组的数字 */
if(flag)
{
out[cnt].tag = ;
out[cnt++].u.num = sum;
flag = ;
sum = ;
}
/* 读取优先级高的非数字字符(字符')'优先级0) 或者 操作符栈为空 */
if(priority(str[i])>priority(top(&cstack))||isempty(&cstack))
{
push(&cstack, str[i]);
continue;
}
/* 读取的字符是右括号，一次处理完括号内数字\操作符\包括'('*/
if(str[i] == ')')
{
while(top(&cstack) != '(')
{
out[cnt].tag = ;
out[cnt].u.ch = top(&cstack); //操作符进后缀表达式数组的字符
cnt++;
pop(&cstack);
}
pop(&cstack);// '('
continue;
}
/* 处理括号外数字及操作符*/
while(!isempty(&cstack)&&top(&cstack)!='(')
{
out[cnt].tag = ;
out[cnt++].u.ch = top(&cstack);//操作符进后缀表达式数组的字符
pop(&cstack);
}
/* 低级别操作符入栈 */
if(str[i])
push(&cstack,str[i]);
}
/* 打印后缀表达式 */ //100 2 3 + * 4 - 100*(2+3)-4
for(i=;i<cnt;++i)
{
if(out[i].tag==)
printf("%d ",out[i].u.num);
else printf("%c ",out[i].u.ch);
}
printf("\n");
#ifdef N
/* 2.根据后缀表达式计算(用操作符栈\数字栈) */
for(i=;i<cnt;i++)
{
/* 从后缀表达式结构体数组读取，是数字压数字栈，
然后判断结构体数组是否读完 */
if(out[i].tag == ){
push(&istack,out[i].u.num);
continue;
}
else if(out[i].u.ch=='+'){//数字栈顶元素加到下面元素并弹出栈顶元素
istack.u.idata[istack.top-] += top(&istack);
pop(&istack);
}else if(out[i].u.ch=='-'){//同理减到下面元素并弹出栈顶元素
istack.u.idata[istack.top-] -= top(&istack);
pop(&istack);
}else if(out[i].u.ch=='*'){ //同理乘到下面元素并弹出栈顶元素
istack.u.idata[istack.top-] *= top(&istack);
pop(&istack);
}else if(out[i].u.ch=='/'){ //同理除到下面元素并弹出栈顶元素
istack.u.idata[istack.top-] /= top(&istack);
pop(&istack);
}else if(out[i].u.ch=='^'){//同理幂到下面元素并弹出栈顶元素
istack.u.idata[istack.top-]
= pow(istack.u.idata[istack.top-], top(&istack));
pop(&istack);
} for(j=;j<=istack.top;++j)//一趟后剩余的数字栈遍历打印
printf("%d ",istack.u.idata[j]);
for(j=i+;j<cnt;++j) //一趟后剩余的后缀表达式数字或操作符打印
{
if(out[j].tag==)
printf("%d ",out[j].u.num);
else printf("%c ",out[j].u.ch);
}
printf("\n");
}
#endif
return ;
} /* 是否栈空函数 */
bool isempty(stack *s){
return (s->top == -);
} /* 压栈函数 */
void push(stack *s, int ch){
if(s->tag == ){
s->u.cdata[++s->top] = (char)ch;
}
else{
s->u.idata[++s->top] = ch;
}
} /* 弹栈函数 */
int pop(stack *s){
if(s->tag == ){
return s->u.cdata[s->top--];
}
return s->u.idata[s->top--];
} /* 取栈顶元素函数 */
int top(stack *s){
if(s->tag == ){
return s->u.cdata[s->top];
}
return s->u.idata[s->top];
} /* 是否数字函数 */
bool isnumber(char ch){
return (ch>=''&&ch<='');
} /* 操作符优先级函数 */
int priority(char ch){
if(ch=='+'||ch=='-')
return ;
if(ch=='*'||ch=='/')
return ;
if(ch=='^')
return ;
if(ch=='(')
return ;
return ;
}
栈，统一接口
四、中缀表达式计算
/* c语言的中缀表达式计算*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#define N 256 /* 栈结构体 */
typedef struct{
short tag; //判断类型
union{
int* idata; //整形指针
char* cdata;//字符型指针
}u;
int top;
}stack; /* 栈操作函数声明 */
void push(stack*, int); //压栈
int pop(stack*); //出栈
int top(stack*); //栈顶元素
void calculate(stack *ist, stack *cst);//计算
bool isempty(stack*); //栈空
int priority(char); //运算符优先级
bool isnumber(char); //字符数字
char* StrOperation(char* r);//字符串整理
int match(char ch); //字符匹配 int main()
{
stack istack, cstack;//数字栈 运算符栈 istack.tag = ;
istack.u.idata = (int*)malloc(sizeof(int)*N);
istack.top = -; //数字栈空 cstack.tag = ;
cstack.u.cdata = (char*)malloc(sizeof(char)*N);
cstack.top = -; //运算符栈空 char str[N];//中缀表达式字符串
int sum = ;//累加数字 gets(str);//读取中缀表达式字符串(含空白符的字符串)
StrOperation(str); //整理字符串
printf("%s\n" ,str); int len = strlen(str);//读取的中缀表达式字符串长度
int flag = ;//是数字标识 for(int i=; i<=len ; i++) // 100*(2+3)-4 100 2 3 + * 4 -
{ //---------------------------------第一, 数字\运算符进栈
if(isnumber(str[i]))//累加数字
{
sum = sum* + str[i] - '';
flag = ;//是数字标识
continue;
}
//1.数字进栈
if(flag)/*为了保证最后一个数字进数字栈, 读到字符串结束标记时也要循环一次 */
{
push(&istack, sum);//数字进栈
flag = ;
sum = ;
}
//2.运算符栈入栈(高级运算符)
/* 栈空或运算符优先级比栈顶高,运算符入栈保证下面可以正常运算 */
if(priority(str[i])>priority(top(&cstack))||isempty(&cstack))
{
push(&cstack, str[i]);
continue;
}
//----------------------------------第二, 处理括号内数字\运算符
//3.处理括号里的操作数\运算符
/* 计算数字栈, 数字栈\运算符栈出栈 最后'('运算符出栈*/
if(str[i] == ')')
{
while(top(&cstack) != '(')
{
calculate(&istack,&cstack);
}
pop(&cstack);//'(' 出栈
continue; //返回为下次运算准备数字\运算符栈
}
//-----------------------------------第三, 处理括号外数字\运算符
//4.除了'('不处理, 循环处理数字栈\运算符栈
while(top(&cstack)!='('&&!isempty(&cstack))
{
calculate(&istack,&cstack);
}
//5.确保低级运算符入运算符栈
if(str[i]){ //确保最后的字符串结束标记, 不被读入运算符栈
push(&cstack,str[i]);
}
}
printf("%d\n",top(&istack));
return ;
} /* 是否栈空函数 */
bool isempty(stack *s){
return (s->top == -);
} /* 压栈函数 */
void push(stack *s, int ch){
if(s->tag == ){
s->u.cdata[++s->top] = (char)ch;
}
else{
s->u.idata[++s->top] = ch;
}
} /* 弹栈函数 */
int pop(stack *s){
if(s->tag == ){
return s->u.cdata[s->top--];
}
return s->u.idata[s->top--];
} /* 取栈顶元素函数 */
int top(stack *s){
if(s->tag == ){
return s->u.cdata[s->top];
}
return s->u.idata[s->top];
} /* 表达式运算 */
void calculate(stack *ist, stack *cst)
{
switch(top(cst)){
case '+':ist->u.idata[ist->top-] += top(ist);break;
case '-':ist->u.idata[ist->top-] -= top(ist);break;
case '*':ist->u.idata[ist->top-] *= top(ist);break;
case '/':ist->u.idata[ist->top-] /= top(ist);break;
case '^':ist->u.idata[ist->top-]
= pow(ist->u.idata[ist->top-], top(ist));break;
}
pop(ist);
pop(cst);
} /* 是否数字函数 */
bool isnumber(char ch){
return (ch>=''&&ch<='');
} /* 操作符优先级函数 */
int priority(char ch)
{
if(ch=='+'||ch=='-')
return ;
if(ch=='*'||ch=='/')
return ;
if(ch=='^')
return ;
if(ch=='(')
return ;
return ;
} /* 字符串处理函数 */
char* StrOperation(char* r){
if(r==NULL)
return NULL;
char* t = r;
while(*t)
{
if(match(*t)){
t++;
continue;
}
*t = '\0';
strcat(r,t+);
}
return r;
} /* 字符匹配函数 */
int match(char ch){
char key[] = "+-*/^()0123456789";
for(int i=; key[i]; ++i)
if(ch == key[i]) return ;
return ;
}
中缀表达式计算，包括整理字符串
五、结构体数组表示中缀表达式
#include <stdio.h>
#include <stdlib.h> typedef struct {
short tag;
union {
double num;
char ch;
}u;
}EXPRESSION; bool isnumber(char ch){
return (ch>=''&&ch<='');
} int main()
{
char str[] = "1.23*(15.1+33.26)"; EXPRESSION e[];
int index = , flag = ; for(int i=; str[i]; ++i)
{
if(isnumber(str[i])||str[i] == '.'){
if(flag){
e[index].u.num = atof(&str[i]);
e[index++].tag = ;
flag = ;
}
continue;
}
e[index].u.ch = str[i];
e[index++].tag = ;
flag = ;
} for(int i=; i<index; ++i){
if(e[i].tag) printf("%.2f", e[i].u.num);
else printf("%c", e[i].u.ch);
} return ;
}
字符串转浮点+字符
c语言，中缀表达式转后缀表达式并计算的更多相关文章
- 栈的简单应用之中缀表达式转后缀表达式(C语言实现逆波兰式)
一.前言 普通人在书写计算式时会选择中缀表达式,这样符合人脑的认知习惯.可计算机处理时后缀表达式才能使处理速度更快,其原因是利用堆栈结构减少计算机内存访问.同时它也是一个很好锻炼栈这个数据结构的应 ...
- C语言- 基础数据结构和算法 - 09 栈的应用_中缀表达式转后缀表达式20220611
09 栈的应用_中缀表达式转后缀表达式20220611 听黑马程序员教程<基础数据结构和算法 (C版本)>, 照着老师所讲抄的, 视频地址https://www.bilibili.com/ ...
- 利用stack结构，将中缀表达式转换为后缀表达式并求值的算法实现
#!/usr/bin/env python # -*- coding: utf-8 -*- # learn <<Problem Solving with Algorithms and Da ...
- RPN-逆波兰计算器-中缀表达式转后缀表达式-javascript
1.利用栈(Stack)来存储操作数和操作符: 2.包含中缀表达式转后缀表达式的函数,这个是难点,也是关键点: 2.1.将输入字符串转为数组: 2.2.对转换来的字符进行遍历:创建一个数组,用来给存储 ...
- 练习3.20 a 将中缀表达式转换为后缀表达式
//将中缀表达式转换为后缀表达式 int main() { ; ]={,,,,,,,}; char tmp; PtrToStack s; s = CreateStack( MaxSize ); ) { ...
- NYOJ--257--郁闷的C小加（一）(中缀表达式变后缀表达式 )
郁闷的C小加(一) 时间限制:1000 ms | 内存限制:65535 KB 难度:3 描述 我们熟悉的表达式如a+b.a+b*(c+d)等都属于中缀表达式.中缀表达式就是(对于双目运算符来说 ...
- .net表达式计算器（中缀表达式转后缀表达式，支持20多个数学函数，支持函数嵌套）
最近在网上查了一下表达工计算器的类库,发现Java版本的有一个比较成熟的叫W3EVal,好像是一个IBM工程师写的,.net就很少了(可能是我了解不够多),但投机取巧的实现思路有很多,比如: (1)将 ...
- hdu-1237 简单计算器---中缀表达式转后缀表达式
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1237 题目大意: 读入一个只包含 +, -, *, / 的非负整数计算表达式,计算该表达式的值. 思路 ...
- 中缀表达式得到后缀表达式(c++、python实现)
将中缀表达式转换为后缀表达式的算法思想如下: 从左往右开始扫描中缀表达式 遇到数字加入到后缀表达式 遇到运算符时: 1.若为‘(’,入栈 2.若为’)‘,把栈中的运算符依次加入后缀表达式,直到出现'( ...
随机推荐
- docker 部署nginx
# 下载镜像 docker pull nginx # 挂载 文件 和文件夹必须存在 docker run -p 80:80 --name mynginx -v $PWD/www:/www -v $P ...
- logback Filter LevelFilter ThresholdFilter
LevelFilter: 级别过滤器,根据日志级别进行过滤.如果日志级别等于配置级别,过滤器会根据onMath 和 onMismatch接收或拒绝日志.有以下子节点: <level>:设置 ...
- WebAPI调用笔记
前言 即时通信项目中初次调用OA接口遇到了一些问题,因为本人从业后几乎一直做CS端项目,一个简单的WebAPI调用居然浪费了不少时间,特此记录. 接口描述 首先说明一下,基于Http协议的Get.Po ...
- 跟我一步一步写出MongoDB Web 可视化工具（二）
前言 上篇讲了一些基础,主要注重的是查,包括建立数据库链接.获取数据库.获取表.列出数据库.列出表.列出索引.获取数据等. 本篇依然是基础,注重增改删,废话不多说,咱们开始. 进阶 创建一个数据库和一 ...
- 3.4 自动测试初步《精通ASP.NET MVC 5》
概述 ASP.NET MVC 框架已被设计成易于建立自动测试,并易于采用诸如测试驱动开发(TDD)等的开发方法学.ASP.NET MVC 为自动化测试提供了一个理想平台. 从广义上讲,当今的 Web ...
- promise知识点小结
断断续续学习es6也有一段时间了,趁着开学空闲对知识点做一些小结. 为什么使用promise 谈到Promise,我们知道,这是社区较理想的异步编程解决方案.想要掌握promise,我们首先要知道其提 ...
- 如何用python将一个时间序列转化成有监督学习
机器学习可以被用于时间序列预测. 在机器学习能使用之前,时间序列预测需要被重新转化成有监督学习.将一个序列组合成成对的输入输出序列. 在这篇教程中,你会发现如何通过使用机器学习算法将单变量和多变量的时 ...
- c语言五子棋
#include <stdio.h>#include <stdlib.h>#include <windows.h>#include <conio.h> ...
- Arch Linux VMware虚拟机（新手）安装教程
准备工作: 下载好Arch Linux的镜像文件 百度打开Arch官网点击download(下载)转到下载界面,点击磁力下载或者种子下载(官网默认是英文,英文不好的童鞋可以安装浏览器翻译插件,本 ...
- Get 请求 与 Post 请求的区别
最直观的区别就是GET把参数包含在URL中,POST通过request body传递参数.举例: 在我大万维网世界中,TCP就像汽车,我们用TCP来运输数据,它很可靠,从来不会发生丢件少件的现象.但是 ...