《数据结构》：中缀表达式合法性判断_Amentos的博客-CSDN博客
目录
例 中缀表达式 2*(3+5)+7/1-4 转换为后缀表达式
例 后缀表达式 2 3 5 + * 7 1 / + 4 - 的计算
1、中缀表达式：
操作符以中缀形式位于运算数中间（如：3+2），是我们日常通用的算术和逻辑公式表示方法。
2、后缀表达式：
又称逆波兰式（Reverse Polish Notation - RPN），操作符以后缀形式位于两个运算数后（如：3+2的后缀表达形式就是3 2 +）。
3、前缀表达式：
又称波兰式（Polish Notation），操作符以前缀形式位于两个运算数前（如：3+2的前缀表达形式就是+ 3 2）。
中缀表达式往往需要使用括号将操作符和对应的操作数括起来，用于指示运算的次序
e.g：5*(2+1) 虽然 * 的优先级高于 + ，但括号的存在表示应优先执行括号内的 + 运算。
中缀表达式适合于人类的思维结构和运算习惯，但并不适用于计算机
尤其是包含括号的中缀表达式，对计算机而言是非常复杂的结构。
适用于计算机的后缀表达式
与中缀表达式不同，后缀表达式不需要使用括号来标识操作符的优先级。
后缀表达式的计算按 操作符 从左到右出现的顺序依次执行(不考虑运算符之间的优先级)，对于计算机而言是比较简单的结构。
从左至右依次遍历中缀表达式各个字符（需要准备一个字符栈存储操作符和括号）
1、字符为 运算数 ：
直接送入后缀表达式（注：需要先分析出完整的运算数）。
2、字符为 左括号 ：
直接入栈（注：左括号入栈后优先级降至最低）。
3、字符为 右括号 ：
直接出栈，并将出栈字符依次送入后缀表达式，直到栈顶字符为左括号（左括号也要出栈，但不送入后缀表达式）。
总结：只要满足 栈顶为左括号 即可进行最后一次出栈。
4、字符为 操作符 ：
若栈空，直接入栈。
若栈非空，判断栈顶操作符，若栈顶操作符优先级低于该操作符，该操作符入栈；否则一直出栈，并将出栈字符依次送入后缀表达式，直到栈空或栈顶操作符优先级低于该操作符，该操作符再入栈。
总结：只要满足 栈空 或者 优先级高于栈顶操作符 即可停止出栈，并将该操作符入栈。
5、重复以上步骤直至遍历完成中缀表达式，接着判断字符栈是否为空，非空则直接出栈，并将出栈字符依次送入后缀表达式。
注：中缀表达式遍历完成，栈中可能还有字符未输出，故需要判断栈空。
从左至右依次遍历中缀表达式各个字符：
第一个字符为运算数，直接输出：
第二个字符为操作符，满足 栈空/优先级高于栈顶操作符 条件，该操作符入栈：
第三个字符为左括号，直接入栈（入栈后优先级降至最低）：
第四个字符为运算数，直接输出：
第五个字符为操作符，满足 栈空/优先级高于栈顶操作符 条件，该操作符入栈：
第六个字符为运算数，直接输出：
第七个字符为右括号，直接出栈并输出，直到栈顶为左括号时进行最后一次出栈(不输出)：
第八个字符为操作符，不满足 栈空/优先级高于栈顶操作符 条件，出栈直至满足条件
第九个字符为运算数，直接输出：
第十个字符为操作符，满足 栈空/优先级高于栈顶操作符 条件，该操作符入栈：
第十一个字符为运算数，直接输出：
第十二个字符为操作符，不满足 栈空/优先级高于栈顶操作符 条件，出栈直至满足条件：
第十三个字符为运算数，直接输出：
中缀表达式遍历完成，判断字符栈中是否还有操作符，如有则出栈并输出：
转换完成：
从左至右依次遍历后缀表达式各个字符（需要准备一个运算数栈存储运算数和操作结果）
1、字符为 运算数 ：
直接入栈（注：需要先分析出完整的运算数并将其转换为对应的数据类型）
2、字符为 操作符 ：
连续出栈两次，使用出栈的两个数据进行相应计算，并将计算结果入栈
e.g：第一个出栈的运算数为 a ，第二个出栈的运算数为 b ，此时的操作符为 - ，则计算 b-a （注：a和b顺序不能反），并将结果入栈。
3、重复以上步骤直至遍历完成后缀表达式，最后栈中的数据就是中缀表达式的计算结果。
从左至右依次遍历后缀表达式各个字符：
第一个字符为运算数，直接入栈：
第二个字符为运算数，直接入栈：
第三个字符为运算数，直接入栈：
第四个字符为操作符，直接出栈两次：
继续出栈：
执行： 第二次出栈运算数 操作符 第一次出栈运算数
即：3 + 5
结果：8
将计算结果入栈：
第五个字符为操作符，直接出栈两次：
执行： 第二次出栈运算数 操作符 第一次出栈运算数
即：2 * 8
结果：16
将计算结果入栈：
第六个字符为运算数，直接入栈：
第七个字符为运算数，直接入栈：
第八个字符为操作符，直接出栈两次：
执行： 第二次出栈运算数 操作符 第一次出栈运算数
即：7 / 1
结果：7
将计算结果入栈：
第九个字符为操作符，直接出栈两次：
执行： 第二次出栈运算数 操作符 第一次出栈运算数
即：16 + 7
结果：23
将计算结果入栈：
第十个字符为运算数，直接入栈：
第十一个字符为操作符，直接出栈两次：
执行： 第二次出栈运算数 操作符 第一次出栈运算数
即：23 - 4
结果：19
将计算结果入栈：
后缀表达式遍历完成，栈中数据即为最终计算结果：
程序代码：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include<ctype.h>
#define ERROR 0
#define OK 1
#define STACK_INT_SIZE 10 /*存储空间初始分配量*/
#define STACKINCREMENT 5 /*存储空间分配增量*/
#define M 50
typedef char ElemType; /*定义字符数据类型*/
typedef double ElemType2; /*定义运算数数据类型*/
/*字符栈*/
typedef struct{
ElemType *base;
ElemType *top;
int stacksize;
}SqStack;
/*运算数栈*/
typedef struct{
ElemType2 *base;
ElemType2 *top;
int stacksize;
}NStack;
int InitStack(SqStack *S); /*构造空栈*/
int push(SqStack *S,ElemType e); /*入栈*/
int Pop(SqStack *S,ElemType *e); /*出栈*/
int StackEmpty(SqStack *s); /*栈空判断*/
void in2post(ElemType *str,ElemType *p); /*中缀表达式转后缀表达式*/
double cal_post(char *str); /*计算后缀表达式*/
/*字符栈初始化*/
int InitStack(SqStack *S){
S->base=(ElemType *)malloc(STACK_INT_SIZE * sizeof(ElemType));
if(!S->base)
return ERROR; //分配失败
S->top = S->base;
S->stacksize = STACK_INT_SIZE;
return OK;
}/*InitStack*/
/*运算数栈初始化*/
int InitStack_N(NStack *S){
S->base=(ElemType2 *)malloc(STACK_INT_SIZE * sizeof(ElemType2));
if(!S->base)
return ERROR;
S->top = S->base;
S->stacksize = STACK_INT_SIZE;
return OK;
}
/*字符栈入栈*/
int Push(SqStack *S,ElemType e){
//判断栈满
if(S->top - S->base >= S->stacksize){
S->base = (ElemType *)realloc(S->base,(S->stacksize + STACKINCREMENT)*sizeof(ElemType));
if(NULL == S->base) //分配失败
return ERROR;
S->top = S->base + S->stacksize;
S->stacksize = S->stacksize+STACKINCREMENT;
}
*S->top = e;
S->top++;
return OK;
}
/*运算数栈入栈*/
int Push_N(NStack *S,ElemType2 e){
if(S->top - S->base >= S->stacksize){
S->base = (ElemType2 *)realloc(S->base,(S->stacksize + STACKINCREMENT)*sizeof(ElemType2));
if(NULL == S->base)
return ERROR;
S->top = S->base + S->stacksize;
S->stacksize = S->stacksize+STACKINCREMENT;
}
*S->top = e;
S->top++;
return OK;
}
/*字符栈出栈*/
int Pop(SqStack *S,ElemType *e){
//判断栈空
if(S->top == S->base)
return ERROR;
S->top--;
*e=*S->top;
return OK;
}/*Pop*/
/*运算数栈出栈*/
int Pop_N(NStack *S,ElemType2 *e){
if(S->top == S->base)
return ERROR;
S->top--;
*e=*S->top;
return OK;
}
/*判断栈空*/
int StackEmpty(SqStack *s){
if(s->top == s->base)
return OK;
return ERROR;
}/*StackEmpty*/
//str为待转换的中缀表达式字符串,p为转换后的后缀表达式字符串
void in2post(ElemType *str,ElemType *p){ /*infix to postfix*/
SqStack s;
InitStack(&s); //初始化一个空字符栈
ElemType e;
int i;
int j=0;
for(i=0 ; i<strlen(str) ; i++) //遍历中缀表达式
{
//遇到数字和小数点直接输出
//使用循环完整接收一个运算数
while(isdigit(str[i]) || '.'==str[i])
{
p[j++]=str[i++];
if(!isdigit(str[i]) && '.'!=str[i])
p[j++]=' '; //一个数字完整输出后使用空格与其它运算符或数字分隔开
}
//遇到左括号直接入栈
if('('==str[i])
Push(&s,str[i]);
//遇到右括号直接出栈，直到栈顶为左括号
if(')'==str[i])
{
while('(' != *(s.top-1))
{
Pop(&s,&e);
p[j++]=e;
p[j++]=' ';
}
Pop(&s,&e); //左括号出栈但不输出
}
//遇到+或—
//1.栈空/栈顶为左括号:直接入栈
//2.否则一直出栈,直到栈空/栈顶为左括号,再入栈
if('+'==str[i] || '-'==str[i])
{
while(!StackEmpty(&s) && '('!=*(s.top-1))
{
Pop(&s,&e);
p[j++]=e;
p[j++]=' ';
}
Push(&s,str[i]);
}
//遇到*或/
//1.栈空/栈顶为左括号/栈顶操作符为+ or -:直接入栈
//2.否则一直出栈,直到满足1,再入栈
if('*'==str[i] || '/'==str[i] || '%'==str[i])
{
while(!StackEmpty(&s) && '('!=*(s.top-1) && '+'!=*(s.top-1) && '-'!=*(s.top-1))
{
Pop(&s,&e);
p[j++]=e;
p[j++]=' ';
}
Push(&s,str[i]);
}
}
//中缀表达式遍历完成,还需检查栈中是否有未输出字符
//判断栈空,非空则直接出栈并输出(左括号不用输出)
while(!StackEmpty(&s)){
Pop(&s,&e);
if('('!=e)
{
p[j++]=e;
p[j++]=' ';
}
}
p[--j]='\0';
}/*infix2postfix*/
//str为待计算的后缀表达式,返回值为计算结果
double cal_post(char *str){ /*计算后缀表达式*/
int i;
ElemType2 e,a,b;
char d[M];
NStack n;
InitStack_N(&n); //初始化一个运算数栈保存运算数
for(i=0;i<strlen(str);i++)
{
int j=0;
while(isdigit(str[i]) || '.'==str[i])
{
d[j++]=str[i++];
d[j]='\0';
if(!isdigit(str[i]) && '.'!=str[i])
{
e=atof(d); //使用atof()将字符串形式的运算数转换为double型数据
Push_N(&n,e); //运算数入栈
}
}
switch(str[i])
{
case '+':
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a+b);
break;
case '-':
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a-b);
break;
case '*':
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a*b);
break;
case '/':
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a/b);
break;
}
}
Pop_N(&n,&e);
return e;
}/*calculate_postfix*/
int main()
{
char str[M];
char post[M];
int i;
printf("\n输入一串中缀表达式：\n");
gets(str);
printf("\n对应的后缀表达式：\n");
in2post(str,post);
printf("%s",post);
printf("\n\n计算后缀表达式：\n");
printf("%f",cal_post(post));
return 0;
}运行结果：
上面的代码正确运算的前提是：
① 输入的中缀表达式合法
② 运算数非负数
例如 ：输入 3*(-6+5) ，得到以下结果，后缀表达式和运算结果明显不正确。
这里的 -6 应该才是一个完整的运算数，但是在后缀表达式中 '-' 号和数字 '6' 被拆分开来了，得到的结果也不正确。因为代码中对于 '-' 号一律是作为操作符处理，所以面对像 -6 这样的负数时不能分析出完整正确的运算数。
所以需要对运算数分析的代码添加负数的处理，修改后的代码如下：
in2post 函数代码修改：
void in2post(ElemType *str,ElemType *p){ /*infix to postfix*/
//初始化一个空栈
SqStack s;
InitStack(&s);
ElemType e;
int i;
int j=0;
for(i=0 ; i<strlen(str) ; i++) //遍历中缀表达式
{
if('-' == str[i]) //负数情况判断
{
//表达式首位是'-',则一定是作为负数符号
if(0 == i)
p[j++]=str[i++];
//'-'前面是'(',则一定是作为负数符号
else if('(' == str[i-1])
p[j++]=str[i++];
}
//遇到数字和小数点直接输出
while(isdigit(str[i]) || '.'==str[i])
{
p[j++]=str[i++];
if(!isdigit(str[i]) && '.'!=str[i])
p[j++]=' '; //一个数字完整输出后使用空格与其它运算符或数字分隔开
}
//遇到左括号直接入栈
if('('==str[i])
Push(&s,str[i]);
//遇到右括号直接出栈，直到左括号出栈(左括号不输出)
if(')'==str[i])
{
while('(' != *(s.top-1))
{
Pop(&s,&e);
p[j++]=e;
p[j++]=' ';
}
Pop(&s,&e); //左括号出栈但不输出
}
//遇到+或—
//1.栈空/栈顶为左括号:直接入栈
//2.否则一直出栈,直到栈空/栈顶为左括号,再入栈
if('+'==str[i] || '-'==str[i])
{
while(!StackEmpty(&s) && '('!=*(s.top-1)) //栈非空 且 栈顶非左括号
{
Pop(&s,&e);
p[j++]=e;
p[j++]=' ';
}
Push(&s,str[i]);
}
//遇到*或/
//1.栈空/栈顶为左括号/栈顶操作符为+ or -:直接入栈
//2.否则一直出栈,直到满足1,再入栈
if('*'==str[i] || '/'==str[i] || '%'==str[i])
{
while(!StackEmpty(&s) && '('!=*(s.top-1) && '+'!=*(s.top-1) && '-'!=*(s.top-1))
{
Pop(&s,&e);
p[j++]=e;
p[j++]=' ';
}
Push(&s,str[i]);
}
}
//中缀表达式遍历完成,还需检查栈中是否有未输出字符
//判断栈空,非空则直接出栈并输出(左括号不用输出)
while(!StackEmpty(&s)){
Pop(&s,&e);
if('('!=e)
{
p[j++]=e;
p[j++]=' ';
}
}
p[--j]='\0';
}
cal_post 函数代码修改：
double cal_post(char *str){
ElemType2 e,a,b;
char d[M];
//初始化一个运算数栈保存运算数
NStack n;
InitStack_N(&n);
int i=0;
int j=0;
while(str[i]) //遍历后缀表达式
{
switch(str[i])
{
case '-':
if( isdigit(str[i+1]) ) //判断'-'是作为负数符号or运算符
{
d[j++]=str[i++]; //将负号加入运算数字符串
d[j]='\0';
break; //注:这里的break只是跳出switch循环
}
else
{
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a-b);
i++;
break;
}
case '+':
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a+b);
i++;
break;
case '*':
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a*b);
i++;
break;
case '/':
Pop_N(&n,&b);
Pop_N(&n,&a);
Push_N(&n,a/b);
i++;
break;
case ' ':i++;
}
//遇到运算数直接入栈(先转换double类型)
//d保存后缀表达式中的字符串形式的运算数
//使用atof将字符串转换为double类型
while(isdigit(str[i]) || '.'==str[i])
{
d[j++]=str[i++];
d[j]='\0';
if( ' ' == str[i] )
{
e = atof(d); //此时分析出的就是完整的运算数
Push_N(&n,e);
i++;
j = 0;
}
}
}
Pop_N(&n,&e);
return e;
}
我想将html转换为纯文本。不过，我不想只删除标签，我想智能地保留尽可能多的格式。为插入换行符标签，检测段落并格式化它们等。输入非常简单，通常是格式良好的html(不是整个文档，只是一堆内容，通常没有anchor或图像)。我可以将几个正则表达式放在一起，让我达到80%，但我认为可能有一些现有的解决方案更智能。 最佳答案 首先，不要尝试为此使用正则表达式。很有可能你会想出一个脆弱/脆弱的解决方案，它会随着HTML的变化而崩溃，或者很难管理和维护。您可以使用Nokogiri快速解析HTML并提取文本:require'nokogiri'h
我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i
在我的应用程序中，我需要能够找到所有数字子字符串，然后扫描每个子字符串，找到第一个匹配范围(例如5到15之间)的子字符串，并将该实例替换为另一个字符串“X”。我的测试字符串s="1foo100bar10gee1"我的初始模式是1个或多个数字的任何字符串，例如，re=Regexp.new(/\d+/)matches=s.scan(re)给出["1","100","10","1"]如果我想用“X”替换第N个匹配项，并且只替换第N个匹配项，我该怎么做？例如，如果我想替换第三个匹配项“10”(匹配项[2])，我不能只说s[matches[2]]="X"因为它做了两次替换“1fooX0barXg
这里是Ruby新手。完成一些练习后碰壁了。练习:计算一系列成绩的字母等级创建一个方法get_grade来接受测试分数数组。数组中的每个分数应介于0和100之间，其中100是最大分数。计算平均分并将字母等级作为字符串返回，即“A”、“B”、“C”、“D”、“E”或“F”。我一直返回错误:avg.rb:1:syntaxerror,unexpectedtLBRACK,expecting')'defget_grade([100,90,80])^avg.rb:1:syntaxerror,unexpected')',expecting$end这是我目前所拥有的。我想坚持使用下面的方法或.join，
有时我需要处理键/值数据。我不喜欢使用数组，因为它们在大小上没有限制(很容易不小心添加超过2个项目，而且您最终需要稍后验证大小)。此外，0和1的索引变成了魔数(MagicNumber)，并且在传达含义方面做得很差(“当我说0时，我的意思是head...”)。散列也不合适，因为可能会不小心添加额外的条目。我写了下面的类来解决这个问题:classPairattr_accessor:head,:taildefinitialize(h,t)@head,@tail=h,tendend它工作得很好并且解决了问题，但我很想知道:Ruby标准库是否已经带有这样一个类？ 最佳
给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。更准确地说:我正在使用Ruby，我想解析XML和JSON数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为JSON、XML和可能的HTML。我可以为此使用Builder模式吗？在任何提到的情况下，我都有某种结构化数据-无论是在内存中还是文本中-我想用它来构建其他东西。我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种XML格式。 最佳答案 我最
我正在尝试使用Curbgem执行以下POST以解析云curl-XPOST\-H"X-Parse-Application-Id:PARSE_APP_ID"\-H"X-Parse-REST-API-Key:PARSE_API_KEY"\-H"Content-Type:image/jpeg"\--data-binary'@myPicture.jpg'\https://api.parse.com/1/files/pic.jpg用这个:curl=Curl::Easy.new("https://api.parse.com/1/files/lion.jpg")curl.multipart_form_
无论您是想搭建桌面端、WEB端或者移动端APP应用，HOOPSPlatform组件都可以为您提供弹性的3D集成架构，同时，由工业领域3D技术专家组成的HOOPS技术团队也能为您提供技术支持服务。如果您的客户期望有一种在多个平台（桌面/WEB/APP，而且某些客户端是“瘦”客户端）快速、方便地将数据接入到3D应用系统的解决方案，并且当访问数据时，在各个平台上的性能和用户体验保持一致，HOOPSPlatform将帮助您完成。利用HOOPSPlatform，您可以开发在任何环境下的3D基础应用架构。HOOPSPlatform可以帮您打造3D创新型产品，HOOPSSDK包含的技术有：快速且准确的CAD
本教程将在Unity3D中混合Optitrack与数据手套的数据流，在人体运动的基础上，添加双手手指部分的运动。双手手背的角度仍由Optitrack提供，数据手套提供双手手指的角度。 01 客户端软件分别安装MotiveBody与MotionVenus并校准人体与数据手套。MotiveBodyMotionVenus数据手套使用、校准流程参照：https://gitee.com/foheart_1/foheart-h1-data-summary.git02 数据转发打开MotiveBody软件的Streaming，开始向Unity3D广播数据；MotionVenus中设置->选项选择Unit
文章目录一、概述简介原理模块二、配置Mysql使用版本环境要求1.操作系统2.mysql要求三、配置canal-server离线下载在线下载上传解压修改配置单机配置集群配置分库分表配置1.修改全局配置2.实例配置垂直分库水平分库3.修改group-instance.xml4.启动监听四、配置canal-adapter1修改启动配置2配置映射文件3启动ES数据同步查询所有订阅同步数据同步开关启动4.验证五、配置canal-admin一、概述简介canal是Alibaba旗下的一款开源项目，Java开发。基于数据库增量日志解析，提供增量数据订阅&消费。Git地址：https://github.co