C语言之四则运算表达式求值(链栈)—支持浮点型数据，负数， 整型数据运算

 运算符间的优先级关系：

链栈结构体定义：

数据域使用字符串长度为20的字符数组(故需要注意判断读取的字符串是运算符还是数值)

可支持浮点型数据，负数， 整型数据的运算

float EvaluateExpression() 函数实现步骤：

1）初始化OPTR栈和OPND栈，将表达式起始符 “#” 压入OPTR栈。

2）扫描表达式，读入第一个字符串str，如果表达式没有扫描完毕至 "#" 或压入OPTR的栈顶元素不为 "#" 时，则循环执行以下操作：

　　——>使用  str_to_float() 函数判断输入的字符串str是否是运算符

　　　　——>如果str不是运算符，则压入OPND栈，读取下一个字符串str

　　　　——>如果字符串str是运算符，使用 Precede() 函数获取OPTR栈顶元素的运算符和字符串str的运算符的优先级：

　　　　　　——>若是 ‘<’ ，则字符串str压入OPTR栈，读入下一个字符串str

　　　　　　——>若是 ‘>’ ，则弹出OPTR栈顶的运算符字符串，从OPND栈弹出两个数值字符串，使用 Operate() 函数对两个字符串进行运算，将得到的浮点型运算结果使用  float_to_str() 函数转换成字符串型数据，压入OPND栈

　　　　　　——>若是 ‘=’ ，则OPTR的栈顶元素是 "(" 且 str 是 ")" ，这时弹出OPTR栈顶的 "(" ，相当于括号匹配成功，然后读入下一字符串str

3)OPND栈顶元素记为表达式求值结果，输出运算结果。

实现代码(.cpp后缀文件)

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

 #define inf float(0x3f3f3f3f)
 #define MAXSIZE 100

 char priority[] = {'+', '-', '*', '/', '(', ')', '#'};

 char priority_relationship[][] = {
     {'>', '>', '<', '<', '<', '>', '>'},
     {'>', '>', '<', '<', '<', '>', '>'},
     {'>', '>', '>', '>', '<', '>', '>'},
     {'>', '>', '>', '>', '<', '>', '>'},
     {'<', '<', '<', '<', '<', '=', ' '},
     {'>', '>', '>', '>', ' ', '>', '>'},
     {'<', '<', '<', '<', '<', ' ', '='}
 }; // 各个运算符之间的优先级关系

 int get_index(char str[])
 {// 获取相应运算符的索引
     for(int i = ; i < ; i++)
     {
         if(str[] == priority[i]) return i;
     }
     printf("未找到匹配的字符\n");
 }

 char Precede(char inside_data[], char input_data[])
 {// 获取两个运算符之间的优先级关系
     int inside_index = get_index(inside_data);
     int input_index = get_index(input_data);

     return priority_relationship[inside_index][input_index];
 }

 typedef struct StackNode
 {
     char data[MAXSIZE];   // 压入栈里面的数据都是字符型，在进行运行时，记得将字符型数字转换为浮点型数字
     struct StackNode *next;
 }StackNode, *LinkStack;

 void InitStack(LinkStack &S)
 {// 构造一个空栈S，栈顶指针置空
     S = NULL;
 }

 void Push(LinkStack &S, char data[])
 {// 在栈顶插入元素data
     StackNode *p;

     p = (StackNode *)malloc(sizeof(StackNode));  // 生成新的结点
     strcpy(p->data, data);  // 将新结点的数据域置为data
     p->next = S;    // 将新结点插入栈顶
     S = p;    // 修改栈顶指针为p
 }

 char *Pop(LinkStack &S)
 {// 删除S的栈顶元素， 用data返回其值
     char data[MAXSIZE];
     if(S == NULL) printf("错误！！！\n栈为空， 无法执行删除命令...");
     else
     {
         StackNode *p;

         strcpy(data, S->data);  // 将栈顶元素赋给data
         p = S;   // 用p临时保存栈顶元素的空间，以备释放
         S = S->next;   //修改栈顶指针
         free(p);    // 释放原栈顶元素的空间
         return data;
     }
 }

 char *GetTop(LinkStack &S)
 {// 获取栈顶元素
     if(S != NULL)
         return S->data;
     else
     {
         printf("错误！！！\n栈顶为空");
         return "";
     }
 }

 float str_to_float(char *str)
 {// 将字符串数据转换成浮点型数据
     float num = ;
     int state_1 = ;  // 用于判断是否读取到小数点的状态值, 0代表还没有读取到
     int state_2 = ; //用于判断是否读取到负号的状态值， 0代表还没有读取到
     while(( *str != '\0' && *str >= '' && *str <= '') || *str == '.' || (*str == '-' && *(str + ) != '\0'))
     {// 注意判断小数点和负号
         if(*str == '.') state_1 = ;  // 当读取到小数点的时候， 状态值state_1赋值为1
         else if(*str == '-') state_2 = ;  // 当读取到负号的时候， 状态值state_2赋值为1
         else
         {
             if(state_1 == ) num = num *  + (*str - '');
             else
             {
                 num += (*str - '') * pow(0.1, state_1);
                 state_1++;
             }
         }
         str++;
     }
     if(*str != '\0') return inf;
     else if(state_2 == )
     {
         return num * -;
     }
     else return num;
 }

 char *float_to_str(float num)
 {// 将浮点型数据装换成字符串数据，保留浮点型数据小数点后4位的值
     char str[MAXSIZE];
     sprintf(str, "%.4f", num);  // 保留小数点后4位
     return str;
 }

 float Operate(char a[], char theta[], char b[])
 {//执行运算
     float a_num = str_to_float(a);
     float b_num = str_to_float(b);

     if(theta[] == '+') return a_num + b_num;
     else if(theta[] == '-') return a_num - b_num;
     else if(theta[] == '*') return a_num * b_num;
     else if(theta[] == '/') return a_num / b_num;
     else printf("错误！！！\n无该运算符");
 }

 void EvaluateExpression()
 {
     StackNode *OPND, *OPTR;
     char str[MAXSIZE];
     char theta[MAXSIZE];
     char a[MAXSIZE];
     char b[MAXSIZE];

     InitStack(OPND);  // 初始化栈 OPND
     InitStack(OPTR);  // 初始化栈 OPTR
     Push(OPTR, "#");  // 将 "#" 压入栈OPTR

     printf("请输入算术表达式（支持负数，浮点型数据），每个值用空格隔开输入，并以#结束\n");
     scanf("%s", str);
     while(str[] != '#' || GetTop(OPTR)[] != '#')
     {
         if(str_to_float(str) != inf)
         { // 如果str不是运算符，则压入OPND栈，读取下一个字符串str
             Push(OPND, str);  // 将字符串str压入OPTR栈
             scanf("%s", str);  // 读入下一个字符串str
         }
         else
         { // 如果字符串str是运算符，使用 Precede() 函数获取OPTR栈顶元素的运算符和字符串str的运算符的优先级
             switch (Precede(GetTop(OPTR), str))  // 使用 Precede() 函数获取相应优先级
             {
             case '<':
                 Push(OPTR, str);  // 将字符串str压入OPTR栈
                 scanf("%s", str);  // 读入下一个字符串str
                 break;
             case '>':
                 strcpy(theta, Pop(OPTR));  // 弹出OPTR栈顶的运算符字符串并赋值给变量 theta
                 strcpy(b, Pop(OPND));   // 弹出OPND栈顶的数值字符串并赋值给变量 b
                 strcpy(a, Pop(OPND));   // 弹出OPND栈顶的数值字符串并赋值给变量 a
                 char temp_str[MAXSIZE];
                 strcpy(temp_str, float_to_str(Operate(a, theta, b))); // 根据相应的三个字符串进行运算，把结果赋给temp_str
                 Push(OPND, temp_str);  // 将运算结果 temp_str 压入OPND栈
                 break;
             case '=':
                 Pop(OPTR);  // 弹出OPTR栈顶的运算符字符串
                 scanf("%s", str);  // 读入下一个字符串str
                 break;
             default:
                 printf("错误！！！\n该优先级不存在！！！");
             }
         }
     }
     printf("%s\n", GetTop(OPND));
 }

 int main(void)
 {
     EvaluateExpression();

     system("pause");
     return ;
 }

运行结果：