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[7] = {'+', '-', '*', '/', '(', ')', '#'};

char priority_relationship[7][7] = {
    {'>', '>', '<', '<', '<', '>', '>'}, 
    {'>', '>', '<', '<', '<', '>', '>'}, 
    {'>', '>', '>', '>', '<', '>', '>'}, 
    {'>', '>', '>', '>', '<', '>', '>'}, 
    {'<', '<', '<', '<', '<', '=', ' '}, 
    {'>', '>', '>', '>', ' ', '>', '>'}, 
    {'<', '<', '<', '<', '<', ' ', '='} 
}; // 各個運算符之間的優先級關系

int get_index(char str[])
{// 獲取相應運算符的索引
    for(int i = 0; i < 7; i++)
    {
        if(str[0] == 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 "0";
    }
}

float str_to_float(char *str)
{// 將字符串數據轉換成浮點型數據
    float num = 0;
    int state_1 = 0;  // 用於判斷是否讀取到小數點的狀態值, 0代表還沒有讀取到
    int state_2 = 0; //用於判斷是否讀取到負號的狀態值， 0代表還沒有讀取到
    while(( *str != '\0' && *str >= '0' && *str <= '9') || *str == '.' || (*str == '-' && *(str + 1) != '\0'))
    {// 注意判斷小數點和負號
        if(*str == '.') state_1 = 1;  // 當讀取到小數點的時候， 狀態值state_1賦值為1
        else if(*str == '-') state_2 = 1;  // 當讀取到負號的時候， 狀態值state_2賦值為1
        else
        {
            if(state_1 == 0) num = num * 10 + (*str - '0');
            else
            {
                num += (*str - '0') * pow(0.1, state_1);
                state_1++;
            }
        }
        str++;
    }
    if(*str != '\0') return inf;
    else if(state_2 == 1)
    {
        return num * -1;
    }
    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[0] == '+') return a_num + b_num;
    else if(theta[0] == '-') return a_num - b_num;
    else if(theta[0] == '*') return a_num * b_num;
    else if(theta[0] == '/') 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[0] != '#' || GetTop(OPTR)[0] != '#')
    {
        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 0;
}

 

 

運行結果：