重言式判别 (数据结构课程设计)

花了一下午在写这个重言式判别，可能是我孤陋寡闻了，总感觉这个名字怪怪的，就是判断一个永真式、永假式、可满足式了，书上面就要说是"重言式"。判断这个所谓重言式，核心算法就是用真值表啦，试过所有取值。

具体代码如下(可能有bug)：有些难理解的我都有注释




/**//********************************************************************


created: 2007/11/09




author: 刺猬





purpose: 判断表达式的属性 永真式 永假式 可满足式


*********************************************************************/


#include<stdio.h>


#include<stdlib.h>








typedef struct exp...{


char data;


int weight;


}express;






express symbolrepresent[27];


express originalexpression[50];




int trueforever=0;


int falseforever=0;


int originalexpressionlength =0;


int symbolrepresentlength=0;




//欢迎屏幕


void ShowWelcome()




...{


printf(" ");


printf(" ");


printf(" ");


printf(" ");


printf(" * * * * * * * * * * * * * * * * * * * * * * * * ");


printf(" * 数据结构课程设计: * ");


printf(" * * * * * * * * * * * * * * * * * * * * * * * * ");


printf(" ");


printf(" 06052711班 ");


printf(" 刺猬 ");


printf(" ");


}




//表达式分析器 分析权值 把 | 权值设为1 &设为2 ~设为3
//处理括号的思路是：遇见左括号 把里面权值提升4 遇见右括号 把权值减去4 这样可以处理多括号问题




int analyse(express *p)




...{


int weight=0;


int length=0;


printf("请输入表达式，并以回车符为结束: ");


printf("注意:请自行检查输入表达式的正确性 ");


while(scanf("%c",&(p->data))&&p->data!=10)




...{


if(p->data>=97&&p->data<=122)


p->data=p->data-32;


switch(p->data)




...{


case '(':


weight=weight+4; //遇见左括号 把里面权值提升4


p->weight=0; //注意括号权值为0


break;


case ')':


weight=weight-4; //遇见右括号 把权值减去4


p->weight=0;


break;


case '|':


p->weight=weight+1;


break;


case '&':


p->weight=weight+2;


break;


case '~':


p->weight=weight+3;


break;


default:


p->weight=0; //imply the data is char


break;


}


p++;


length++;


}


return length;


}




//查找表达式中权值最小的，作为子树的根节点


int findMin(express *originalexpression,int start,int end)




...{


int key=0;


int current=start;


int location=0;


while(!originalexpression[current].weight)




...{key=originalexpression[current].weight;current++;}


key=current>end?key:originalexpression[current].weight;


location=current>end?0:current;


while(current<=end)




...{


if(originalexpression[current].weight&&originalexpression[current].weight<key)




...{


location=current;


key=originalexpression[current].weight;


}


current++;


}


return location;


}






//分析原表达式，提取所有变量 就是把所有变量罗列在一个数组内


int makeSymbolReprentArray(express *originalexpression)




...{


int length=0;




int hashmap[26]=...{0};


while(originalexpression->data!=10)




...{


if(originalexpression->data>=65&&originalexpression->data<=90)




...{


if(!hashmap[(int)(originalexpression->data-65)])




...{


hashmap[(int)(originalexpression->data-65)]=1;


symbolrepresent[length].data=originalexpression->data;


length++;


}


}


originalexpression++;


}


return length;


}




//查找每个变量所代表值 0或1


int findSymbolRepresent(char symbol)




...{


int location=0;


while(symbolrepresent[location].data!=symbol)




...{


location++;


}


return symbolrepresent[location].weight;


}




//虚拟构建一个二叉树 注意并没有真正构建 不过可理解为建立一个树了 算法核心是一个类似中序遍历二叉树


int virtualCreateTree(express *originalexpression,int start,int end) //在以start和end的范围内建子树




...{


int key=0;


if(start==end) //start==end 表明这个是叶子节点 那么里面是个变量


return findSymbolRepresent(originalexpression[start].data);


else if(start>end)


return 1; //start>end 处理~的特殊情况


else




...{


key=findMin(originalexpression,start,end); //寻找最小权值 作为子树根节点


switch(originalexpression[key].data)




...{


case '|':


return(virtualCreateTree(originalexpression,start,key-1)||virtualCreateTree(originalexpression,key+1,end));


break;


case '&':


return(virtualCreateTree(originalexpression,start,key-1)&&virtualCreateTree(originalexpression,key+1,end));


break;


case '~': //注意~的处理 实际上我是用的(1&&!右子树)


return(virtualCreateTree(originalexpression,start,key-1)&&(!virtualCreateTree(originalexpression,key+1,end)));


}


}





}




//递归给所有变量赋值 注意递归思想用回溯二叉树理解


void recursion(express *symbolrepresent,int i,int length)




...{


if(i<length)




...{


symbolrepresent[i].weight=1; //当前变量取1


recursion(symbolrepresent,i+1,length); //递归调用下一个变量


symbolrepresent[i].weight=0; //当前变量取0


recursion(symbolrepresent,i+1,length); //递归调用下一个变量


}


else //递归结束啦




...{


if(!trueforever||!falseforever) //注意这个处理 当表达式出现可真情况和可假情况 那么断定它是可满足式 没必要做下去了




...{


switch(virtualCreateTree(originalexpression,0,originalexpressionlength-1))




...{


case 1:


trueforever++;


break;


case 0:


falseforever++;


break;


default :


break;


}


}


else


return ;


}


}




//结果处理 没啥说的


void resultReturn(int symbolrepresentlength)




...{


int i=0;


if(trueforever&&falseforever)




...{


printf("您输入的变量名序列为: ");


while(i<symbolrepresentlength)




...{printf("%c ",symbolrepresent[i].data);i++;}


printf(" ");


printf("satisfactible ");


}


else if(!trueforever)


printf("falseforever ");


else


printf("trueforever ");


}




//用户自己设置值 也没啥说的


void userSetWeight()




...{


int i=0;


printf("请依次为变量赋值,并以回车键结束: ");


while(i<symbolrepresentlength)




...{


printf("%c: ",symbolrepresent[i].data);


scanf("%d",&symbolrepresent[i].weight);


i++;


}


if(virtualCreateTree(originalexpression,0,originalexpressionlength-1))


trueforever++;


else


falseforever++;


}




//主目录


void mainFunctionMenus()




...{


int menu=0;


printf("请选择您的变量设值方式: ");


printf("1.计算机自动穷举 ");


printf("2.用户指定设置 ");


scanf("%d",&menu);


if(1==menu)


recursion(symbolrepresent,0,symbolrepresentlength);


else


userSetWeight();


}






int main()




...{


ShowWelcome();


originalexpressionlength = analyse(originalexpression);


symbolrepresentlength = makeSymbolReprentArray(originalexpression);


mainFunctionMenus();


resultReturn(symbolrepresentlength);


//printf("%d",analyse(exp));


//printf(" %d",findMin(exp,0,analyse(exp);))


return 0;


}