信息检索上机报告.docx

信息检索上机报告.docx

《信息检索上机报告.docx》由会员分享，可在线阅读，更多相关《信息检索上机报告.docx（5页珍藏版）》请在冰豆网上搜索。

信息检索上机报告

信息检索上机报告

　　　　　　　　信息储存与检索上机报告　　　　　　　　姓名：

马云学号：

06121001日期：

　　　　逆波兰变换　　一、上机题目：

　　编写算法和程序，实现布尔检索式的逆波兰变换。

　　二、试验编程语言：

C语言三、程序设计总体思路：

　　1、建立两个栈：

算项指针栈和算符栈。

　　2、将表达式送入表达式数组，从左向右扫描检索提问表达式中的字符，对当前字符做如下处理：

　　⑴如果是算项，将指向该算项的指针放到算项栈中。

⑵如果是“”，则将算符栈中“（”以及“（”以上的算符出栈。

　　⑶如果是运算符+-*,将他们与算符栈栈顶算符进行比较，如果优先级高于那个算符，将此算符进栈。

如果低于算符栈栈顶算符，则把那个算符作为树的根节点。

这时算项栈栈顶指针出栈，其所指字符作为右孩子，再将此时算项栈栈顶指针出栈,作为该根节点的左孩子；再将指向该根节点的指针入算项栈。

也就是将此时的这棵树作为了一个算项。

如此循环直到表达式数组最后一个运算符为终止符“﹒”。

一棵表达式二叉树建立完成。

　　3、后序遍历此二叉树，显示逆波兰表达式。

　　四、程序源代码　　#include\#include\#include#include　　typedefstruct{chars[20][20];inttop;}SQ;voidcopystr（char*a,char*b）{　　inti=0;　　do　　{　　b[i]=a[i];　　i++;　　}　　while（a[i]!

=‘\\0’）;　　b[i]=‘\\0’;}　　voidvoidSQ（SQ*s）{　　s->top=-1;}　　intifempty（SQ*s）{　　return（s->top==-1）;}　　voidpush（SQ*S,char*c）{　　if（S->top==19）　　printf（\else　　{　　S->top++;　　copystr（c,S->s[S->top]）;　　}}　　char*pop（SQ*S）{　　if（ifempty（S））　　{　　printf（\　　return（NULL）;　　}　　else　　return（S->s[S->top--]）;}　　intjudge（char*c）{　　if（c[1]==‘\\0’）　　switch（c[0]）　　{　　case‘+’:

return（3）;　　case‘-’:

return（3）;　　case‘*’:

return

（2）;　　case‘/’:

return

（2）;　　default:

return

（1）;　　}　　else　　return

（1）;}　　voidwrite（char*a,char*b,char*c）{　　strcat（a,c）;　　strcat（a,b）;　　}　　intseek（char*c,intstart）{　　intsignal=1;　　for（start=start++;c[start]!

=‘\\0’&&signal!

=0;start++）　　{　　if（c[start]==‘）’）　　signal--;　　elseif（c[start]==‘（‘）　　signal++;　　}　　if（signal==0）　　return（start-1）;　　else　　{　　printf（\输入无效式子\\n\　　return（-1）;　　}}　　voidFB（SQ*A,SQ*B）{　　for（;!

ifempty（A）;）　　{　　push（B,A->s[A->top]）;　　pop（A）;　　}}　　char*rewrite（char*A）{　　SQfront;　　SQback;　　inti,j,k,flag=0;　　char*result;　　charmid[20];　　voidSQ（&front）;　　voidSQ（&back）;　　for（i=0;A[i]!

=‘\\0’;）　　{　　if（A[i]==‘（‘）　　{　　j=seek（A,i）;　　for（k=i+1;k　　{　　　　mid[k-i-1]=A[k];　　}　　mid[j-i-1]=‘\\0’;　　copystr（rewrite（mid）,mid）;　　push（&back,mid）;　　i=j+1;　　}　　elseif（A[i]!

=‘（‘）　　{　　mid[0]=A[i];　　mid[1]=‘\\0’;　　push（&back,mid）;　　i++;　　}　　}　　FB（&back,&front）;　　for（;>=2;）　　{　　flag=0;　　for（i=0;i　　if（judge（[i]）==2）　　{　　　　flag=1;　　break;　　}　　}　　if（flag==1）　　{　　for（;>=2;）　　{　　　　if（judge（）==1&&judge（）==2&&judge（）==1）　　　　{　　　　write（,,）;　　　　push（&back,）;　　　　pop（&front）;　　　　pop（&front）;　　　　pop（&front）;　　}　　else

　　　　　　　　{　　　　push（&back,）;　　　　pop（&front）;　　}　　}　　FB（&front,&back）;　　FB（&back,&front）;　　}　　else　　{　　for（;>=2;）　　{　　　　if（judge（）==1&&judge（）==3&&judge（）==1）　　　　{　　　　write（,,）;　　　　push（&back,）;　　　　pop（&front）;　　　　pop（&front）;　　　　pop（&front）;　　}　　else　　{　　　　push（&back,）;　　　　pop（&front）;　　}　　}　　FB（&front,&back）;　　FB（&back,&front）;　　}　　}　　result=;　　return（result）;}　　　　voidmain（）{　　charre[20];　　chara[20];　　printf（\请输入算式：

\\n\　　scanf（\　　copystr（rewrite（a）,re）;　　printf（\逆波兰式：

\\n%s\\n\　　}　　五、程序运行结果　　将中缀表达式：

a*（b+（c-d））转换为逆波兰形式　　　　　　六、上机结果分析与总结　　能够实现检索提问表达式的逆波兰形式输出，结果正确。

检索指令必须是精确匹配，友好性不是很好。

　　程序调试环境为Win-Tc,不能在中文DOS环境下运行，直观性差。

　　准波兰　　一、上机题目：

　　编写算法和程序，实现布尔检索式的准波兰变换。

　　二、试验编程语言：

C语言三、程序设计总体思路：

　　在逆波兰变换的基础上，进一步实现准波兰变换：

如上题程序中，建立前缀表达式的二叉树。

利用递归调用的思想，将每个节点左右子树的深度进行比较，如果右子树　　的深度大于左子树，将它们调换；如果小于或相等，则不动。

后序遍历打印二叉树，输出的即为准波兰表达式。

　　如下图，即为二叉树变换为可以后序遍历生成准波兰表达式的树的过程：

　　四、程序源代码　　//:

Definestheentrypointfortheconsoleapplication.//　　　　#include\#include#include#include#include　　typedefstructnode　　/*结构体*/{　　charchValue;　　structnode*pLeftChild,*pRightChild;　　/*指向左右节点的指针*/}BiNode;　　　　BiNode*GenerateTree（char*pFormula）;　　/*一般表达式生成树*/intDepthTree（BiNode*pRoot）;voidChangeTree（BiNode*pRoot）;　　voidPostOrderPrintTree（BiNode*pRoot）;　　/*后续打印*/　　voidPostOrderFreeTree（BiNode*pRoot）;　　/*释放节点*/　　voidmain（）　　{charFormula[100],*a;　　BiNode*pRoot;　　　　printf（\请输入算式:

\\n\　　a=Formula;　　scanf（\　　pRoot=GenerateTree（Formula）;/*返回根节点的指针*/　　printf（\　　pri　if（op==oper[i]）　　{　　return1;　　}　　}　　return0;}　　intGetOperPri（charop）　　　　/*求运算符的优先级*/{　　switch（op）　　{case‘（‘:

　　return1;　　case‘+’:

　　case‘-’:

　　return2;　　case‘*’:

　　return3;　　case‘.’:

　　return4;　　default:

　　return0;　　}}　　staticcharOperStack[100];　　/*操作符栈*/staticBiNode*NodeStack[100];　　/*节点指针栈*/intOperLen=0;　　　　/*栈长度*/intNodeLen=0;　　PushOper（charop）　　　　/*压栈*/{　　OperStack[OperLen++]=op;}　　charPopOper（）　　　　/*出栈*/{　　returnOperStack[--OperLen];}　　intSizeOper（）　　　　/*栈长度,返回0表示空栈*/{　　returnOperLen;}　　charTopOper（）　　　　/*栈顶元素*/{　　returnOperStack[OperLen-1];}　　PushNode（BiNode*no）{　　NodeStack[NodeLen++]=no;}　　BiNode*PopNode（）{　　returnNodeStack[--NodeLen];}　　intSizeNode（）{　　returnNodeLen;}　　BiNode*GenerateTree（char*pFormula）{　　BiNode*pNode;　　charch,c;　　intidx=0;　　　　ch=pFormula[idx++];　　while（0!

=SizeOper（）||‘\\0’!

=ch）　　{　　if（‘\\0’!

=ch&&!

IsOper（ch））/*不是运算符，则算项进栈*/　　{　　pNode=（BiNode*）malloc（sizeof（BiNode））;　　

　　　　　　pNode->chValue=ch;　　pNode->pLeftChild=NULL;　　pNode->pRightChild=NULL;　　PushNode（pNode）;　　ch=pFormula[idx++];　　}　　　　else　　{　　switch（ch）　　{　　case‘（‘:

/*进栈*/　　　　PushOper（‘（‘）;　　　　ch=pFormula[idx++];　　　　break;　　case‘）’:

/*脱括号*/　　　　while

（1）　　{　　　　c=PopOper（）;　　　　if（‘（‘==c）　　　　break;　　　　pNode=（BiNode*）malloc（sizeof（BiNode））;　　　　pNode->chValue=c;　　　　pNode->pLeftChild=NULL;　　　　pNode->pRightChild=NULL;　　　　if（0!

=SizeNode（））　　　　pNode->pRightChild=PopNode（）;if（0!

=SizeNode（））　　　　pNode->pLeftChild=PopNode（）;　　　　PushNode（pNode）;　　}　　　　ch=pFormula[idx++];　　break;　　default:

　　　　if（0==SizeOper（）||‘\\0’!

=ch&&GetOperPri（TopOper（））　　　　ch=pFormula[idx++];　　　　}　　　　else　　　　{/*出栈*/　　　　pNode=（BiNode*）malloc（sizeof（BiNode））;　　　　pNode->chValue=PopOper（）;　　　　pNode->pLeftChild=NULL;　　　　pNode->pRightChild=NULL;　　　　if（SizeNode（））　　　　pNode->pRightChild=PopNode（）;　　　　if（SizeNode（））　　　　pNode->pLeftChild=PopNode（）;　　　　PushNode（pNode）;　　　　/*PopOper（）;*/　　　　}　　　　break;　　}　　}　　}　　pNode=PopNode（）;/*根节点*/　　returnpNode;}　　intDepthTree（BiNode*pRoot）　　/*树深度*/{　　intl,r;　　if（pRoot==NULL）return0;　　l=DepthTree（pRoot->pLeftChild）;　　r=DepthTree（pRoot->pRightChild）;　　return（l>=r?

l+1:

r+1）;　　}　　voidChangeTree（BiNode*pRoot）　　/*如果右子树大于左子树，交换*/{　　BiNode*pTree=NULL;　　if（NULL!

=pRoot）　　{if（DepthTree（pRoot->pLeftChild）pRightChild））　　{pTree=pRoot->pRightChild;　　pRoot->pRightChild=pRoot->pLeftChild;　　pRoot->pLeftChild=pTree;　　}　　ChangeTree（pRoot->pLeftChild）;　　ChangeTree（pRoot->pRightChild）;　　}}　　　　voidPostOrderPrintTree（BiNode*pRoot）　　{if（NULL!

=pRoot）　　{　　PostOrderPrintTree（pRoot->pLeftChild）;　　PostOrderPrintTree（pRoot->pRightChild）;　　printf（\　　}}voidPostOrderFreeTree（BiNode*pRoot）{　　if（NULL!

=pRoot）　　{　　PostOrderFreeTree（pRoot->pLeftChild）;　　PostOrderFreeTree（pRoot->pRightChild）;　　free（pRoot）;　　}}　　　　五、程序运行结果　　　　　　六、上机结果分析与总结　　能够实现检索提问表达式的准波兰形式输出，结果正确。

　　准波兰是对逆波兰变换的改进，在子树根不对称时，先处理较大分支，这样占用工作区较少。

该方法算法稍微复杂，不过只在已有逆波兰检索系统上增加一个重组模块，可以将内存工作区从7个降低至5个。

　　另外，在编程过程中，暴露出自己编程的知识还不够扎实。

以后需加强。

　　检索指令表　　将表达式a+b*c-d变为检索指令的过程：

地址检索词特征内容01a00102b00203c00304d1*检索词表1+0041—0。

逆波兰输出区　　　　生成的检索指令表为：

操作码第一操作数第二操作数第三操作数输入1011输入1022输入1033与4234或3142输入11非5123存储237终止0　　将表达式a-（b+c）*d变为检索指令的过程：

特征内容地址检索词00101a00202b00303c1+04d004检索词表1*　　1—　　0。

　　逆波兰输出区　　　　生成的检索指令表为：

操作码第一操作数第二操作数第三操作数输入1011输入1022输入1033或3234输入12与4243非5132存储227终止0　　　　将表达式（a-b）*c+d变为检索指令的过程：

地址检索词特征内容01a00102b00203c1—04d003检索词表1*0041+0。

逆波兰输出区生成的检索指令表为：

操作码第一操作数第二操作数第三操作数输入1011输入1022非5123输入1031与4132输入1041或3123存储237终止0　　

　　　　　　将表达式（a-b）*c+d变为检索指令的过程：

地址检索词特征内容01a00102b00203c1—04d003检索词表1*0041+0。

逆波兰输出区生成的检索指令表为：

操作码第一操作数第二操作数第三操作数输入1011输入1022非5123输入1031与4132输入1041或3123存储237终止0