#include <stdio.h>
#include<stdlib.h>
#include<conio.h>

#include <math.h>
#include <string.h>

struct CAUSE_TYPE
{ char *cause; /*事实字符串指针*/
struct CAUSE_TYPE *next;
//float ce; //省略
//float weigh; //省略
}; /*规则链表的结构描述*/
struct RULE_TYPE
{
char *result; /*结论字符串指针*/
int lastflag; /*结论规则标志*/
// float ce; //省略
//float yu; //省略
struct CAUSE_TYPE *cause_chain; /*事实链表指针*/
struct RULE_TYPE *next;
// bool Used=false;
};
struct CAUSE_TYPE*DataBase;
struct CAUSE_TYPE*Conclusion;
struct RULE_TYPE *KnowledgeBase;
struct RULE_TYPE *Used;
void freeKB(struct RULE_TYPE*);
void freeDB(struct cause_TYPE*);
int FindCause(char *);
void markKB();
void createKB();
void inputDB();
void think();
void explain();

/*释放条件链表*/
void freeDB(struct CAUSE_TYPE * cPoint)
{
struct CAUSE_TYPE * cp;
while(cPoint)
{
cp=cPoint->next;
free(cPoint->cause);
cPoint->cause=NULL;
cPoint->next=NULL;
free(cPoint);
cPoint=cp;
}
}
/*释放规则链表*/
void freeKB(struct RULE_TYPE * rPoint)
{
struct RULE_TYPE * rp;
while(rPoint)
{
rp=rPoint->next;
freeDB(rPoint->cause_chain);
rPoint->cause_chain=NULL;
free(rPoint->result);
rPoint->result=NULL;
rPoint->next=NULL;
free(rPoint);
rPoint=rp;
}
}
/*整理输入的规则，找出结论性的规则并打上标记*/
void markKB()
{
struct RULE_TYPE * rp1,rp2;
struct CAUSE_TYPE * cp;
rp1=KnowledgeBase;
while(rp1)
{
cp=rp1->cause_chain;
rp1->lastflag=1;
while(cp)
{
rp2=KnowledgeBase;
while(rp2)
{/*该规则结论是某规则的条件，则将该规则置为非结论规则*/
if(strcmp(rp2->result,cp->cause)==0)
rp2->lastflag=0;
rp2=rp2->next;
}
cp=cp->next;

}
rp1=rp1->next;

}
}
/*建立知识库*/
void createKB()
{
FILE *fp;
struct CAUSE_TYPE * cp=NULL;
struct RULE_TYPE * rp=NULL;
int i,j;
char sp[80];
char ch;
/*释放知识库规则链标记已使用的规则链表*/
freeKB(KnowledgeBase);
freeKB(Used);

KnowledgeBase=Used=NNLL;
if((fp=fopen(".\ \rule.dat","r"))==NULL)
{
printf("\n知识库不存在！\n");
printf("请输入新的规则，以创建知识库！\n");
/*输入新的知识库规则*/
for(i=1;;i++)
{
printf("\n * * * * * * * * *第(%d) 条规则 * * * * * * * *",i);
printf("\n * * 结论 :(是/会/有)");
/*输入规则的结论部分*/
gets(sp);
if(*sp=='\0') break;
rp=(struct RULE_TYPE *)malloc(sizeof(rp));
rp->result=(char *)malloc(sizeof(sp));
strcpy(rp->result,sp);
rp->cause_chain=NULL;
rp->next=KnowledgeBase=rp;
/*输入规则的条件部分*/
for(j=1;;j++)
{
printf("\n * * *(%d):(//)",j);
/*输入第J个事实*/
gets(sp);
if(*sp=='\0') break;
cp=(struct CAUSE_TYPE * )malloc(sizeof(cp));
cp->cause=(char *)malloc(sizeof(sp));
strcpy(cp->cause,sp);
cp->next=rp->cause_chain;
rp->cause_chain=cp;

}
}
if(!KnowledgeBase)
{
printf("\n警告 !知识库中没有任何规则 !!\n");
return;

printf("\n需要保存已建立的知识库？(Y/N)?");
while(! strchr("YyNn",ch0=getchar()));
if(ch=='Y'|ch=='y')
if((fp=fopen(".\\rule.dat","w"))==NULL)
{
printf("\n写文件有错误!\n")
exit(1);
}
else{
/*保存已建立的知识库*/
rp=KnowledgeBase;
while(rp)
{
fputs(rp->result,fp);
fputc('\n',fp);/*"\n"为结论或事实的终结符*/

cp=rp->cause_chain;
while(cp)
{
fputs(cp->cause,fp);
fputc('\n',fp);
cp=cp->next;
}
fputs("\\\n",fp);/*"\\\n"为一条规则的终结符*/
rp=rp->next;
}
fclose(fp);
}
}
else{
/*若知识库文件存在，则读入所有的规则，建立知识库*/
while(!feof(fp))
{
fgets(sp,80,fp);
if(*sp=='\\')break;
rp=(struct RULE_TYPE*)malloc(sizeof(rp));
rp->result=(char*)malloc(i=strlen(sp));
sp[i-1]='\0';
strcpy(rp->result,sp);
rp->cause_chain=NULL;
rp->next=KnowledgeBase;
KnowledgeBase=rp;

fgets(sp,80,fp);
while(*sp!='\\')
{
cp=(struct CAUSE_TYPE*)malloc(sizeof(cp));
cp->cause=(char*)malloc(i=strlen(sp));
sp[i-1]='\0';
strcpy(cp->cause,sp);
cp->next=rp->cause_chain;
p->cause_chain=cp;
fgets(sp,80,fp);
}
}
fclose(fp);
}
/*给知识库中的所有结论规则打上标记*/
markKB();
}
/*输入已知条件的子程序*/
void inputDB()
{
int i;
char sp[80];
struct CAUSE_TYPE* cp;

/*释放条件链表和推出结论链表*/
freeDB(DataBase);
freeDB(Conclusion);
freeDB=Conclusion=NULL;

printf("\n*****请输入已知事实：\n");
for(i=1;i++)
{
printf("\n**条件(%d):(是/会/有)",i);
gets(sp);
if(*sp=='\0')break;
cp=(struct CAUSE_TYPE*)malloc(sizeof(cp));
cp->cause=(char*)malloc(sizeof(sp));
strcpy(cp->cause,sp);
cp->next=DataBase;
DataBase=cp;
}
}
/*在条件链表几结论链表中查证字符串sp是否存在，若存在返回1，否则返回0*/
int FindCause(char* sp)
{
struct CAUSE_TYPE* cp2;

/*在条件链表中查找*/
cp2=DataBase;
while(cp2)
if(strcmp(sp,cp2->cause)==0)return(1);
else cp2=cp2->next;

/*在结论链表中查找*/
cp2=Conclusion;
while(cp2)
if(strcmp(sp,cp2->cause)==0)return(1);
else cp2=cp2->next;

return(0);
}

/*推理机子程序*/
void think()
{
struct RULE_TYPE* rp1,rp2;
struct CAUSE_TYPE* cp1;
int RuleCount,i;
char sp[80];
/*把规则链表和已使用的规则链表连接起来*/
if(Used)
{rp1=Used;
while(rp1->next) rp1=rp1->next;
rp1->next=KnowledgeBase;
KnowledgeBase=Used;
Used=NULL;
}
/*释放结论链表*/

if(Conclusion)
{
freeDB(Conclusion);
Conclusion=NULL;
}
do
{
RuleCount=0;
rp1=KnowledgeBase;
while(rp1)
{
cp1=rp1->cause_chain;
/*取出一条规则的条件部分，检查是否全部为已知*/
while(cp1)
if(FindCause(cp1->cause)==0) /*若有条件未知，跳出该规则*/
break;
else
cp1=cp1->next; /*若该条件已知，查下一条件*/
if(cp1) /*若该规则的条件已知，查下一条件*/
rp2=rp1;
rp1=rp1->next;}
else if(FindCause(rp1->result)==0)
{

cp1=(struct CAUSE_TYPE *)malloc(sizeof(cp1));
cp1->cause=(char*)malloc(sizeof(rp1->result));
strcpy(cp1->cause,rp1->result);
cp1->next=Conclusion;
Conclusion=cp1;
rp2->next=rp1->next;
rp1->next=Used;
Used=rp1;
rp1=rp2;
RuleCount++;
if(Used->lastflag==1)
{
RuleCount=0;
break;
}
}
else
{
rp2=rp1;
rp1=rp1->next;
}
}
}while(RuleCount>0);
if(!Conclusion||Used->lastflag==0)
{

printf("\n*****已知事实不充分！请输入补充事实：\n ");
cp1=DataBase;
for(i=1; cp1;i++)
printf("\n****条件(%d):(是/会/有)%s\",i,cp1->cause);
cp1=cp1->next;
}
for(; ;i++)
{
printf("\n****条件(%d):(是/会/有)",i);
gets(sp);
if(*sp=='\0')
break;
cp1=(struct CAUSE_TYPE *)malloc(sizeof(cp1));
cp1->cause=(char*)malloc(sizeof(sp));
strcpy(cp1->cause,sp);
cp1->next=DataBase;
DataBase=cp1;
}
}
else printf("\n*****这个动物:(是/会/有)\"%s\"\n ",Conclusion->cause);
}

void expain()
{
struct RULE_TYPE *rp;
struct CAUSE_TYPE *cp;
int i;
rp=Used;
i=0;
while(rp)
{
printf("\n*****这个动物(是/会/有)\"%s\",因为：\n ",rp->result);
cp=rp->cause_chain;
while(cp)
{
printf("*****(%d)-它(是/会/有)\"%s\"\n",i++,cp->cause);
cp=cp->next;
}
rp=rp->next;
}
}

void main()
{printf("下面开始创建动物识别系统的知识库\n");
creatKB();
printf("请输入已知事实\n");
inputDB();
printf("推理\n");
think();
printf("结论\n");
explain();
}