[栈的应用] 打印任意命题公示的真值表和主范式（这是转载同学的）

课本是高等教育出版社出版的《离散数学及其应用》。

程序会自动分析输入的表达式，并且列出真值表，最后打印出主析取范式和主合取范式，最多支持256 个变元。

主要用到的算法：中缀表达式转后缀表达式、后缀表达式求值还有一个二进制加法模拟。

下面上2 个图，第一个是表达式开头没有非运算的（课本P85 例3.5.5）：

第二个不但表达式开头有非运算，而且非运算之后并不是一个数值，而是一个操作符（课本P83 例3.5.4）：

下面是代码，如果CSDN 的编辑器弄乱了就将就着看吧，本来代码的缩进和排版都是整洁的。

file:///main.c

* main.c  * use MinGW Developer Studio to compile  * by iSpeller ([e-mail])  */    #include <stdio.h>   #include <stdlib.h>   #include <string.h>     #define _BUF_LEN    (1<<10)   #define _STACK_LEN  (_BUF_LEN/2)   #define _PROP_LEN   (1<<7)     #define VOID_NUM    (0) /* 不存在的运算数 */   typedef char *  string;  typedef int bool;  #define true    (1)   #define false   (0)   typedef int     data_t;  /* 防止各种老式编译器来大姨妈 */  #ifndef _SIZE_T   typedef unsigned int    size_t;  #endif   #ifndef _SSIZE_T   typedef int ssize_t;  #endif     /* 范式类型，     析取,    合取 */  enum paradigm   { EXTRACT, CONJUNCT, };  /* 优先级大小     等于, 小于,   大于 */  enum priorities { EG=0, NGE=-1, NLE=1, };  /* 联结词（包括英文圆括号）优先级，全真 */  /*     左括号, 非,    合取,  析取, 蕴含,   右括号,  结束符 */  enum { LEFT=5, NOT=4, AND=3, OR=3, CONT=3, RIGHT=2, END=1, };    /* 4个栈，expr 储存后缀表达式，truth_expr 是expr 的真值解释  * ops 储存联结词, truth 做后缀表达式求值栈，truth 最后存放表达式真值   */  struct  stack {      data_t data[_STACK_LEN];      ssize_t len;      size_t len_max;  }expr, truth_expr, ops, truth;    string  input_buf = NULL;   /* 存放输入的表达式 */  struct  prop {        char p; /* 变元名 */      bool v; /* 真值 */  };  struct  table {      struct prop data[_PROP_LEN];      ssize_t len;      size_t len_max;  } prop_table;   /* 原子命题变元的列表 */  typedef int truth_item;  struct truth_table {      truth_item data[_STACK_LEN];      ssize_t len;      size_t len_max;  } truth_table;  /* 真值表 */    #define push(s,a)   ((s).data[++(s).len] = (a))   #define pop(s)      ((s).data[(s).len--])   #define is_empty(s) ((s).len+1)   #define get_top(s)  ((s).data[(s).len])   #define init(s,m)   (((s).len = -1) || ((s).len_max = (m)))     #define STRCMP(a,r,b)   (strcmp ((a), (b)) r 0)     /* 判断字符是否是原子命题变元  */  bool  is_op (char c) {      switch (c) {      case '|':   return OR;      break;      case '&':   return AND;     break;      case '!':   return NOT;     break;      case '>':    return CONT;    break;      case '(':   return LEFT;    break;      case ')':   return RIGHT;   break;      case '#':   return END;     break;        default :   return false;      }  }    /* 判断运算符的优先级  */  enum priorities  get_priority (char op1, char op2) {      if (is_op (op1) == is_op (op2))          return EG;      else if (is_op (op1) < is_op (op2))          return NGE;      else          return NLE;  }    /* 进行数据运算  */  data_t  do_op (char op, bool num1, bool num2) {      bool truth = false;            if('!' == op)           return num1 ? false : true;      switch (op) {      case '|':   truth = (num2 || num1); break;      case '&':   truth = (num2 && num1); break;      case '>':    truth = (num2 && !num1) ? false : true; break;      default:    fprintf (stderr, "Boy, WHAT Did U Have Done!!??\n");                  exit (0);      }      return truth;  }    /* 判断识别的命题变元是否已经存在  */  bool  prop_find (struct prop item) {      ssize_t count = 0;            for (count=0; count<prop_table.len+1; ++count)          if (item.p == prop_table.data[count].p)              return true;      return false;  }    /* 判断变元真值是否设置完毕  * 如果真值全真返回真  */  bool  set_truth_end (void) {      ssize_t count;            for (count=0; count<prop_table.len+1; ++count)          if (!prop_table.data[count].v)              return false;            return true;  }     /* 输出“你好”  */  void  start (void) {      printf ("输入诸如\"P|(Q&R)>!P\" 的表达式，程序将会列出真值表并求出主范式。\n\n");      printf ("其中：\"|\"表示析取；\"&\"表示合取；\"!\"表示非；\">\"表示蕴含。支持英文圆括号。\n");      printf ("字符串处理不是算法的核心，所以不会处理非法输入\n");      printf ("\t----因此当你输入了非法的表达式，你也会得到一个非法的结果 :D\n");      printf ("exit 指令退出。\n\n");  }    /* 要求用户输入表达式和原子命题变元的真值  */  void  get_input () {      char *loc = input_buf;      size_t size = 0;      struct prop item;            /* 清栈 */      init (expr, _STACK_LEN);       init (ops, _STACK_LEN);      init (truth_expr, _STACK_LEN);      init (truth, _STACK_LEN);      init (truth_table, _STACK_LEN);      init (prop_table, _PROP_LEN);            if (!(input_buf = (char *)malloc (_BUF_LEN))) {          perror ("malloc ()");          exit (1);      }                    /* 获取表达式 */      do {          printf (" # ");          if (!fgets (input_buf, _BUF_LEN-1, stdin)) {              perror ("fgets ()");              exit (1);          }          input_buf[strlen (input_buf)-1] = '#';  /* 结束符号 */                if (STRCMP ("exit#", ==, input_buf)) {              printf ("再见 :D\n");              exit (0);          }      } while (STRCMP ("#", ==, input_buf));            /* 识别原子命题变元和联结词并压入变元列表 */      size = strlen (input_buf);      for (loc = input_buf; loc-input_buf < size; ++loc) {          if (' ' != *loc)               if (!is_op (*loc)) {                  item.p = *loc;                  if (!prop_find (item))                      push (prop_table, item);    /* 现在并不赋真值 */              }       }  }    /* input_buf 中的表达式转换为后缀表达式  */  void  make_postfix_expr () {      data_t item;      ssize_t count;      enum priorities level;            push (ops, '#');    /* 栈底元素，结束符号，优先级最小 */      for (count=0; count<strlen (input_buf); ++count) {          item = input_buf[count];                    if (' ' == item)              continue;                    if (!is_op (item))  /* 是操作数则压入表达式栈 */              push (expr, item);          else if (')' == item || '#' == item) {  /* 去除成对的括号和结束标记'#' */              while ('#' != (item = pop (ops)))                  push (expr, item);              pop (ops);          } else {              level = get_priority (item, get_top (ops));                            /* 通过压入一个不存在的操作数，把单目运算符'!'               * 当作双目运算符来处理              */              if ('!' == item)                      push (expr, VOID_NUM);                            if (NLE == level) {     /* 如果后进运算符高于栈顶元素 */                  push (ops, item);       /* 压入运算符栈 */                      if ('(' == item)        /* 如果压入了一个左括号 */                      push (ops, '#');        /* 压入运算符栈一个结束标记来保持正确的优先级 */              } else {                /* 否则 */                  push (expr, pop (ops)); /* 栈顶元素压入表达式栈 */                  push (ops, item);       /* 后进运算符压入运算符栈 */              }          }      }      free (input_buf);  }    /* 设置变元的初始真值，全假  */  void  init_props_truth (void) {      ssize_t count = 0;            for (count=0; count<prop_table.len+1; ++count)           prop_table.data[count].v = false;            for (count=0; count<prop_table.len+1; ++count)          printf ("%d ", prop_table.data[count].v);                /* 立刻计算一次真值,因为其后的计算不包含全假的情况 */      void find_truth (void);      find_truth ();  }    /* 设置变元的真值，把所有变元当做一个二进制数  * 用二进制加法模拟真值，每次调用函数都会给二进制数加一  */  void  set_props_truth (void) {      bool carry = false; /* 进位标志 */      ssize_t count, count2;            for (count=0, carry=true; carry && (count<prop_table.len+1); ++count) {              if (prop_table.data[count].v) {                  prop_table.data[count].v = (carry ? 0 : 1);                  if (prop_table.len>0)                      /* 同时要处理前面的位 */                      for (count2=1; count2<count+1; ++count2)                          prop_table.data[count-count2].v = false;                  carry = (prop_table.data[count].v ? false : true);              } else {                      prop_table.data[count].v = (carry ? 1 : 0);                  carry = false;              }      }            for (count=0; count<prop_table.len+1; ++count)              printf ("%d ", prop_table.data[count].v);      void find_truth (void);      find_truth ();  }    /* 调用函数之时默认prop_table 已经设置了一组有效的真值  * 函数计算在这组真值下整个后缀表达式的真值  */  void  find_truth (void) {      truth_item item;      ssize_t count, count2;      data_t data, num1, num2, ans;            /* 首先把truth_expr 中的变元全部换成真值 */      truth_expr = expr;      for (count=0; count<truth_expr.len+1; ++count) {          data =  truth_expr.data[count];                    if (!is_op (data)) {              for (count2=0; count2<prop_table.len+1; ++count2)                  if (data == prop_table.data[count2].p) {                      truth_expr.data[count] = prop_table.data[count2].v;                      break;                  }          }      }            /* 后缀表达式求值 */      for (count=0; count<truth_expr.len+1; ++count) {          data =  truth_expr.data[count];                    if (!is_op (data))      /* 非运算符 */              push (truth, data);          else {                  /* 是运算符 */              num1 = pop (truth);              num2 = pop (truth);              ans = do_op (data, num1, num2);              push (truth, ans);          }      }               /* 储存真值 */      item = pop (truth);      push (truth_table, item);            /* 顺便打印真值 */      printf ("\t%d\n", truth_table.data[truth_table.len]);  }    /* 打印主范式  */  void      print_main_paradigm (enum paradigm type) {      ssize_t count;      bool has_find;            if ((EXTRACT!=type) && (CONJUNCT!=type))          exit (0);            printf ("主%s范式为 : ", (EXTRACT==type) ? "析取" : "合取");      for (count=0, has_find=false; count<truth_table.len+1; ++count) {          if ((EXTRACT==type)               ? truth_table.data[count]              : !truth_table.data[count]) {              has_find = true;              printf ("%c%d %s ", (EXTRACT==type) ? 'm' : 'M',                                   count,                                  (EXTRACT==type) ? "∨" : "∧");          }      }      if (has_find)          printf ("\b\b  \n");      else           printf ("为空");  }    /* MAIN   */  int  main (int argc, char *argv[]) {      ssize_t count;            start ();            while (true) {          get_input ();          make_postfix_expr ();                    for (count=0; count<prop_table.len+1; ++count) {              printf ("%c ", prop_table.data[count].p);          }          printf ("\t真值\n\n");                    init_props_truth ();                    while (!set_truth_end ())              set_props_truth ();                    print_main_paradigm (EXTRACT);  /* 主析取范式 */          print_main_paradigm (CONJUNCT); /* 主合取范式 */      }            return 0;  }