给出几个数字，如何用计算机穷举所有可能的算式，加减乘除括号

所有可能的算式

/*计算式“1（）2（）3（）4（）5”，选择“+，-，*，/”填入括号内，可使用括号改变运算次序，
使算式的结果等于10。编程输出所有可能的算式。如1+ 2 *(3 + 4)-5=10*/
/*2005-3-10   梁见斌*/

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

#define MAX 30

void  Print(char exp[], int len, FILE *fp);/*输出表达式，并存储在 文件 中*/
int Change(char str[], char exp[]);/*将一般表达式转化为逆波兰表达式*/
int JiSuan(char exp[]); /*求逆波兰表达式的值*/

int main(void)
{
        char *pstr, str[MAX];/*存储原算术表达式*/  
   char *pexp, exp[MAX];/*存储转化成的逆波兰表达式*/
   char fuhao[4]={'+','-','*','/'};/*存储运算符号*/
   char leftch[2]={' ','('};/*存储左括号*/
   char rightch[2]={' ',')'}; /*存储右括号*/
   int xuhao[12]={0};
   int result;   /*存储逆波兰表达式的值*/
   int len;
   int sum1, sum2, l1, l2, l3, l4, r1, r2, r3, r4;
   FILE *fp;
   
   if ( (fp=fopen("cccc.txt","w+")) == NULL)
    {
       fprintf(stderr,"/nError opening file ./n");
       exit(1);
    }
   for(xuhao[0]=0; xuhao[0]<2; xuhao[0]++)/*用穷举法列出所有可能的算式*/
   {
      str[0]=leftch[xuhao[0]];   /*为提高效率，先列出左右括号存在的可能情况，最多有4个左括号4个右括号*/
      if(str[0] == '(')/*判断第一个左括号是否存在*/
              l1=1;
             else
                     l1=0;
            
             for(xuhao[1]=0; xuhao[1]<2; xuhao[1]++)
      {
         str[3]=leftch[xuhao[1]];
         if(str[3] == '(')/*判断第二个左括号是否存在*/
                       l2=1;
                else
                        l2=0;
         
                for(xuhao[2]=0; xuhao[2]<2; xuhao[2]++)
         {
            str[7]=leftch[xuhao[2]];
            if(str[7] == '(')/*判断第三个左括号是否存在*/
                          l3=1;
                   else
                           l3=0;
   
                   for(xuhao[3]=0; xuhao[3]<2; xuhao[3]++)
            {
               str[11]=leftch[xuhao[3]];
               if(str[11] == '(')/*判断第四个左括号是否存在*/
                             l4=1;
                      else
                              l4=0;
              
                      for(xuhao[4]=0; xuhao[4]<2; xuhao[4]++)
               {
                  str[5]=rightch[xuhao[4]];
                  if(str[5] == ')')/*判断第一个右括号是否存在*/
                                r1=1;
                         else
                                 r1=0;
         
                             for(xuhao[5]=0; xuhao[5]<2; xuhao[5]++)
                  {
                     str[9]=rightch[xuhao[5]];
                     if(str[9] == ')')/*判断第二个右括号是否存在*/
                                       r2=1;
                            else
                                    r2=0;
                             
                            for(xuhao[6]=0; xuhao[6]<2; xuhao[6]++)
                     {
                        str[13]=rightch[xuhao[6]];
                        if(str[13] == ')')/*判断第三个右括号是否存在*/
                                r3=1;
                               else
                                       r3=0;
                               
                               for(xuhao[7]=0; xuhao[7]<2; xuhao[7]++)
                        {
                           str[16]=rightch[xuhao[7]];
                           if(str[16] == ')')/*判断第四个右括号是否存在*/
                                         r4=1;
                                  else
                                          r4=0;
                                         
                                  sum1=l1+l2+l3+l4;/*计算左括号的总的个数*/
                                  sum2=r1+r2+r3+r4;/*计算右括号的总的个数*/
                                  if(sum1 == sum2)/*只有左括号的个数等于括号的个数时才进行计算*/
                                   for(xuhao[8]=0; xuhao[8]<4; xuhao[8]++)/*列出每个运算符号的可能情况*/
                              {
                                 str[2]=fuhao[xuhao[8]];
                                 for(xuhao[9]=0; xuhao[9]<4; xuhao[9]++)
                                 {
                                    str[6]=fuhao[xuhao[9]];
                                    for(xuhao[10]=0; xuhao[10]<4; xuhao[10]++)
                                    {
                                       str[10]=fuhao[xuhao[10]];
                                       for(xuhao[11]=0; xuhao[11]<4; xuhao[11]++)
                                       {
                                          str[14]=fuhao[xuhao[11]];
                                          str[1]='1'; str[4]='2';
                                          str[8]='3'; str[12]='4';
                                          str[15]='5'; str[17]='#';
                                          
                                          pstr=str;
                                          pexp=exp;
                                          len=Change(pstr, pexp);/*将一般表达式转化为逆波兰表达式*/
                                                if(-1 == len)/*根据len的返回值决定是否进行计算，-1 == len表示出现错误*/
                                                  ;
                                                else
                                          {
                                             result=JiSuan(pexp);/*根据result的返回值决定是否进行输出*/
                                             if(12345 ==  result)/*12345 ==  result表示出现错误*/
                                                      printf("It's error!/n");
                                             else if( 10 == result)
                                             {  
                                                if(str[3] == '(' && str[5] == ')'/*去掉多余的括号，如（4）*/
                                                        || str[7] == '(' && str[9] == ')'
                                                        || str[11] == '(' && str[13] == ')')
                                                        ;
                                                       else
                                                       {
                                                          fprintf(fp, "正确的算术表达式: ");
                                                   fprintf(stdout, "正确的算术表达式: ");
                                                   Print(pstr, 18, fp);/*输出正确的算术表达式，并存储在文件中*/
                                                       }  
                                             }  
                                          }  
                                       }
                                    }
                                 }   
                              }            
                        }
                     }         
                  }
               }
            }
         }
      }
   }
   fclose(fp);  
   system("pause");
   return 0;
}

void  Print(char exp[], int len, FILE *fp)
{
   int i;
   
    for(i=0; i<len; i++)
    {
        fprintf(fp, "%c", exp[i]);
        fprintf(stdout, "%c", exp[i]);
    }
    printf("/n");
}  

int Change(char str[], char exp[])
{
        int i, t, top;/*t作为exp的下标，top作为stack的下标，i作为str的下标*/
        char stack[MAX], ch;/*作为饯使用*/
       
        t=0;
   i=0;
   top=0;
   stack[0]='#';
   ch=str[i++];
   while(ch != '#')
   {
      if(ch >= '0' && ch <= '9')
              exp[t++]=ch;
             else if(ch == '(')
                     stack[++top]=ch;
                else if(ch == ')')
                {
                   while(stack[top] != '(' && top > 0)
                           exp[t++]=stack[top--];
                if(top == 0)/*表示没有对应的 ')'*/
                  return  -1;
                top--;
                }
      else if(ch == '+' || ch == '-')
      {
         while(top != 0 && stack[top] != '(')
                 exp[t++]=stack[top--];
                stack[++top]=ch;
      }   
      else if(ch == '*' || ch == '/')
      {
         while(stack[top] == '*' || stack[top] == '/')
                       exp[t++]=stack[top--];
                        stack[++top]=ch;
      }   
      
      ch=str[i++];     
   }  
   
    while(top != 0)
   {
      if('(' == stack[top])/*表示有多余的 '(' */
              return  -1;
             else
                     exp[t++]=stack[top--];
   }   
   exp[t]='#';
   return t+1;
}

int JiSuan(char exp[])
{
   int stack[MAX], d;/*作为饯使用*/
   char c;
   int i=0, t=0, top=0;

   c=exp[t++];
   while(c != '#')
   {
      d=c-'0';
      if(c >= '0' && c <= '9')
              stack[top++]=d;
             else
             {
                switch(c)
                {
                   case '+': stack[top-2]=stack[top-2]+stack[top-1];
                                            break;
                             case '-': stack[top-2]=stack[top-2]-stack[top-1];
                                            break;
                   case '*': stack[top-2]=stack[top-2]*stack[top-1];
                                            break;
            case '/': if(stack[top-1] != 0 && stack[top-2]%stack[top-1] == 0 )
                                                               stack[top-2]=stack[top-2]/stack[top-1];/*前后两个数必须能整除，且分母不为0*/
                                                        else                          /*否则返回值12345（表示无效）*/
                                                                return 12345;
                                            break;                             
                }  
         top--;
             }  
      c=exp[t++];
   }
   return stack[top-1];
}