C语言实现24点程序

一、简介

本程序的思想和算法来自于C语言教材后的实训项目，程序通过用户输入四个整数计算出能够通过加减乘除得到数字24的所有表达式，程序的设计有别于一般通过穷举实现的方式，效率得到提高。算法介绍如下：

如用户输入1,2,3,4四个数字，先将其看成四个集合即{1}，{2}，{3}，{4}，整个叫做第一集群，后通过任意两个集合加减乘除{1,2}，{1,3}，{1,4}，{2,3}，{2,4}，{3,4}六个集合叫做第二集群，而第三集群由第一集群和第二集群产生，而第四集群可由第一集群和第三集群以及由第二集群自身产生，最后比较第四集群所得到的的值是否24，输出结果

---

二、程序流程如下：

1. 程序调用input函数处理用户输入，并同时生成四个相应的集合
2. 调用函数calc，通过其中的list_cross函数产生第二、三、四集群
3. 调用函数output输出，并同时删除相同的表达式
4. 删除所有集群所占的空间，程序结束

---

三、主要的数据结构以及算法

为了提高计算精度，使用分数表示每一次计算结果

分数的结构 FRACTION

typedef struct{
    int num;//分子
    int den;//分母
}FRACTION;  //注意分数的符号放在分子上 

集群链表节点 s_ item

 typedef char EXPRESS[]; //存储具体的表达式，如2*3
 typedef struct s_item{
     FRACTION value;      //集合的值 如expr为2*3，value.num=6,value.den=1
     EXPRESS expr;         //表达式
     int flag[];          //每一个元素代表是否使用相应的数字，如用户输入了1,2,3,4，flag{1,1,0,0}，表示
                           //集合含有数字1和2
     struct s_item* next;  //指向下一节点
 }ITEM,*PITEM;

主要的算法

分数的四则运算：

1.声明

int commonDivisor(int a,int b);//最大公约数
int commonMultiple(int a,int b);//最小公倍数
//公倍数和公约数用于化简和计算分数 

FRACTION plus(FRACTION a,FRACTION b);//分数的加法
FRACTION sub(FRACTION a,FRACTION b);//分数的减法
FRACTION multiple(FRACTION a,FRACTION b);//分数乘法
FRACTION division(FRACTION a,FRACTION b);//分数的除法 

2.定义

 //最大公约数
 int commonDivisor(int a,int b){
     int temp=;
     while(b!=){
         temp=a%b;
         a=b;
         b=temp;
     }
     return a;
 }

 //最小公倍数
 int commonMultiple(int a,int b){
     return a*b/commonDivisor(a,b);
 }

 //分数的加法
 FRACTION plus(FRACTION a,FRACTION b){

     if(a.den==b.den){ //分母相同 

         a.num=a.num+b.num;
     }else{
         int cm=commonMultiple(a.den,b.den);
         a.num=a.num*(cm/a.den)+b.num*(cm/b.den);
         a.den=cm;
     }

     //简化a,分子分母同除公约数
     int cm= commonDivisor(abs(a.num),a.den);
     a.num/=cm;
     a.den/=cm;

     return a;
 }

 //分数减法
 FRACTION sub(FRACTION a,FRACTION b){

     if(a.den==b.den){ //分母相同 

         a.num=a.num-b.num;
     }else{
         int cm=commonMultiple(a.den,b.den);
         a.num=a.num*(cm/a.den)-b.num*(cm/b.den);
         a.den=cm;
     }
     //简化a,分子分母同除公约数
     int cm= commonDivisor(abs(a.num),a.den);
     a.num/=cm;
     a.den/=cm;

     return a;
 }

 //分数乘法
 FRACTION multiple(FRACTION a,FRACTION b){

      a.num*=b.num;
      a.den*=b.den;

     int cm= commonDivisor(abs(a.num),a.den);
     a.num/=cm;
     a.den/=cm;

     return a;
 }

 //分数的除法
 FRACTION division(FRACTION a,FRACTION b){
     int temp;
   if(b.num==){
        a.num=;
        a.den=;
        return a;//不能除0 ，返回分子，分母为0，作为标志
   }else if(b.num>){
          temp=b.num;
          b.num=b.den;
          b.den=temp;
   }else{
         temp =abs(b.num);
          b.num=b.den;
          b.den=temp;
          b.num*=-;
   }
   return multiple(a,b);
 }

集合之间的加减乘除产生新集合

1.声明

PITEM add(PITEM a,PITEM b); //两个相加
PITEM divide(PITEM a,PITEM b); //两个相除
PITEM mutiply(PITEM a,PITEM b); //两个相乘
PITEM subtract(PITEM a,PITEM b); //两个相减

2.定义

 PITEM add(PITEM a,PITEM b) //两个相加
 {    

       PITEM x=(struct s_item*)malloc(sizeof(struct s_item));
       x->value=plus(a->value,b->value);

       int m;
       for(m=;m<;m++){
            x->flag[m]=;
       }

       int k=;
       x->expr[k]='(';
       int j;
       for(j=;a->expr[j]!='\0';j++){
             x->expr[++k]=a->expr[j];
       }
       x->expr[++k]='+';
       for(j=;b->expr[j]!='\0';j++){
             x->expr[++k]=b->expr[j];
       }
       x->expr[++k]=')';
       x->expr[++k]='\0';

       int i=;
       for(i=;i<;i++){
              if(a->flag[i]==){
                      x->flag[i]=;
              }

             if(b->flag[i]==){
                 x->flag[i]=;
             }

       }

       x->next=NULL; 

       return x;
 }

 PITEM divide(PITEM a,PITEM b){ //集合相除
      PITEM x=(struct s_item*)malloc(sizeof(struct s_item));
       x->value=division(a->value,b->value);

            int m;
       for(m=;m<;m++){
            x->flag[m]=;
       }
       if(x->value.num==&&x->value.den==){
              free(x);
              return NULL;
       }

          int k=;
       x->expr[k]='(';
       int j;
       for(j=;a->expr[j]!='\0';j++){
             x->expr[++k]=a->expr[j];
       }
       x->expr[++k]='/';
       for(j=;b->expr[j]!='\0';j++){
             x->expr[++k]=b->expr[j];
       }
       x->expr[++k]=')';
       x->expr[++k]='\0';

       int i=;
       for(i=;i<;i++){
              if(a->flag[i]==){
                      x->flag[i]=;
              }

             if(b->flag[i]==){
                 x->flag[i]=;
             }

       }

       x->next=NULL;
       return x;
 }
 PITEM mutiply(PITEM a,PITEM b)//两个相乘
 {
       PITEM x=(struct s_item*)malloc(sizeof(struct s_item));
       x->value=multiple(a->value,b->value);
            int m;
       for(m=;m<;m++){
            x->flag[m]=;
       }
          int k=;
       x->expr[k]='(';
       int j;
       for(j=;a->expr[j]!='\0';j++){
             x->expr[++k]=a->expr[j];
       }
       x->expr[++k]='*';
       for(j=;b->expr[j]!='\0';j++){
             x->expr[++k]=b->expr[j];
       }
       x->expr[++k]=')';
       x->expr[++k]='\0';

       int i=;
       for(i=;i<;i++){
              if(a->flag[i]==){
                      x->flag[i]=;
              }

             if(b->flag[i]==){
                 x->flag[i]=;
             }

       }

       x->next=NULL;
       return x;
 }

 PITEM subtract(PITEM a,PITEM b){  //相减
      PITEM x=(struct s_item*)malloc(sizeof(struct s_item));
       x->value=sub(a->value,b->value);
            int m;
       for(m=;m<;m++){
            x->flag[m]=;
       }
          int k=;
       x->expr[k]='(';
       int j;
       for(j=;a->expr[j]!='\0';j++){
             x->expr[++k]=a->expr[j];
       }
       x->expr[++k]='-';
       for(j=;b->expr[j]!='\0';j++){
             x->expr[++k]=b->expr[j];
       }
       x->expr[++k]=')';
       x->expr[++k]='\0';

       int i=;
       for(i=;i<;i++){
              if(a->flag[i]==){
                      x->flag[i]=;
              }

             if(b->flag[i]==){
                 x->flag[i]=;
             }

       }

       x->next=NULL;
       return x;
 }

核心代码

产生新集群 list_cross

 //比较集群之间是否有相同数字
 int cmp(PITEM left,PITEM right){
     int i;
     for(i=;i<;i++){
         if(left->flag[i]==&&right->flag[i]==){
             return ;
         }
     }
     return ;
 }

 //结合两个集群产生下一个集群
 void list_cross(PITEM left,PITEM right,PITEM result){

         PITEM p,q;
         for(p=left->next;p!=NULL;p=p->next){       //循环调用两个集群中所有集合
         for(q=right->next;q!=NULL;q=q->next)
              if(cmp(p,q)==){         //只有两集合不含相同数字才运算
                    PITEM temp=NULL;
                    if((temp=add(p,q))!=NULL){
                          temp->next=result->next;
                          result->next=temp;
                    }
                     if((temp=subtract(p,q))!=NULL){
                          temp->next=result->next;
                          result->next=temp;
                    }
                     if((temp=divide(p,q))!=NULL){
                          temp->next=result->next;
                          result->next=temp;
                    }
                     if((temp=mutiply(p,q))!=NULL){
                          temp->next=result->next;
                          result->next=temp;
                    } 

              }
     }
 }

因为用户有可能输入相同的数字，所以要消除相同的表达式：

消除重复表达式

 PITEM p=p4_head->next;  //p指向第四集群的头结点，第四集群即最后四个数字都已经使用的集合 

      //消除重复的表达式 

      PITEM q,pre;
      for(;p!=NULL;p=p->next){
          for(q=p->next,pre=p;q!=NULL;){
                 if(strcmp(p->expr,q->expr)==){

                          pre->next=q->next;
                          PITEM temp=q;       //pre为p的前一个节点
                          q=q->next;

                          free(temp);//消失重复点;
                          temp=NULL;

                 }else{
                     q=q->next;
                     pre=pre->next;
                 }
          }
      }

判断集合的值，输出结果

     //输出
     p=p4_head->next;
     while(p!=NULL){
       if(p->value.num==&&p->value.den==){

          puts(p->expr);

     }

         p=p->next;
         } 

四、运行

               

源代码地址:C语言实现24点src