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.若为’)‘,把栈中的运算符依次加入后缀表达式,直到出现'( ...
随机推荐
- 用python算圆周率及进度条提示
(一)圆周率 : (1)圆周率是指平面上圆的周长与直径之比 (ratio of the circumference of a circle to the diameter) .用符号π表示.中国古代有 ...
- DTW动态时间规整算法
目录 1.基本介绍 2.算法原理(理论原理) 2.1 主要术语 2.2 算法由来和改进过程 2.3 DTW算法流程 3.算法DTW和算法HMM的比较 1.基本介绍 DTW:Dynamic Time W ...
- 【图论】最短路问题之spfa
写在算法前面: 前向星存图(一个神奇的超越邻接矩阵的存在) 首先讲一下需要定义的一些东西?? 1.head数组:head[点数]:head[i]表示以当前点i为起点的最后一条边(这里的最后指的是编号[ ...
- xaf 如何添加logo信息
https://documentation.devexpress.com/eXpressAppFramework/113156/Task-Based-Help/Miscellaneous-UI-Cus ...
- 生成SQL Server数据字典
1.表信息 Select * FROM INFORMATION_SCHEMA.COLUMNS order by Table_name; select * from INFORMATION_SCHEMA ...
- idea函数被调用
打开一个复杂的程序或者项目进行分析的时候,我们就需要知道一个方法在哪里被调用,用于迅速厘清代码逻辑.操作如下:选中函数,右键,点击Find Usages. 如图: 操作简单,但右键还是没有快捷键方便. ...
- CSS：margin和padding之谜
margin外边距,padding内边距.光看书本的介绍,理解起来好费劲,那咱就举个荔枝:你家的保险箱,是那种镶在墙壁里的,保险箱与墙壁的距离就是margin,保险箱壁就是所谓的border,保险箱与 ...
- tomcat 7 启动报错：java.lang.NoSuchMethodError: javax.servlet.ServletContext.getSessionCookieConfig()Ljavax/servlet/SessionCookieConfig的解决
现象: tomcat 7 启动报错:java.lang.NoSuchMethodError: javax.servlet.ServletContext.getSessionCookieConfig() ...
- 微信内嵌浏览器打开手机浏览器下载APP（APK）的方法
想必大家会经常碰到网页链接在微信内无法打开和微信内无法打开app下载页的情况.通常这种情况微信会给个提示 “已停止访问该网址” ,那么导致这个情况的因素有哪些呢,主要有以下四点 1.网页链接被举报次数 ...
- 一、linux概述
1． 学习Linux之前先了解Unix Unix是一个强大的多用户.多任务操作系统.于1969年在AT&T的贝尔实验室开发.UNIX的商标权由国际开放标准组织(The Open Group) ...