數據結構課程設計四則運算表達式求值（C語言版）

　 明人不說暗話，直接上百度網盤鏈接，輸入提取碼z3fy即可下載。

    文件中包含程序，程序運行文件，設計報告和測試樣例，應有盡有，歡迎小伙伴們在中下載使用。

    本課程設計為四則運算表達式求值，用於帶小括號的一定范圍內正負數的四則運算標准（中綴）表達式的求值。
注意事項：
    1、請保證輸入的四則表達式的合法性。輸入的中綴表達式中只能含有英文符號“+”、“-”、“*”、“/”、“(”、“)”、“=”、數字“0”到“9”以及小數點“.”，輸入“=”表示輸入結束。例如9+(3-1)*3.567+10/2=，特別是請勿輸入多余空格和中文左右括號。
    2、輸入的中綴表達式默認限定長度是1001，可根據具體情況調整字符串數組的長度。
    3、請保證輸入的操作數在double數據類型范圍內，單個數字有效數字長度不可超過15位。本課程設計中操作數是C語言中的雙精度浮點數類型。
    4、本課程設計中的運算數可以是負數，另外如果是正數可直接省略“+”號（也可帶“+”號）。

　下面的程序正常運行需要在上面的百度網盤中下載相應文件，否則無法正常使用哦。

/*本程序為四則運算表達式求值系統，用於計算帶小括號的四則運算表達式求值。
具體算法：
    先將字符串處理成操作單元（操作數或操作符），再利用棧根據四則運算
的運算法則進行計算，最后得出結果。*/ 

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

const int Expmax_length = 1001;//表達式最大長度，可根據適當情況調整 
struct Ope_unit 
{//定義操作單元 
    int    flag;//=1表示是操作數 =0表示是操作符 -1表示符號單元 
    char   oper;//操作符 
    double real;//操作數，為雙精度浮點數 
};

void Display();//菜單
void Instru(); //使用說明 
int Check(char Exp_arry[]);
void Evalua(); //先調用Conver操作單元化，再調用Calculate函數計算結果並輸出 
int  Conver(struct Ope_unit Opeunit_arry[],char Exp_arry[]);//將字符串處理成操作單元 
int  Isoper(char ch);//判斷合法字符（+ - * / ( ) =）
int  Ope_Compar(char ope1,char ope2);//操作符運算優先級比較 
double Calculate(struct Ope_unit Opeunit_arry[],int Opeunit_count,int &flag);//用棧計算表達式結果 
double Four_arithm(double x,double y,char oper);//四則運算 

int main()
{
    int select;
    while(1)
    {
        Display();
        printf("請輸入欲執行功能對應的數字："); 
        scanf("%d",&select);
        printf("\n");
        switch(select)
        {
            case   1: Evalua(); break;
            case   2: Instru(); break;
            case   0: return 0; 
            default : printf("無該數字對應的功能，請重新輸入\n"); 
                      system("pause");
        }
    }
    return 0;
}

int Check(char Exp_arry[])
{//檢查是否有非法字符，返回1表示不合法，0表示合法 
    int Explength=strlen(Exp_arry),i;
    for(i=0;i<Explength;i++)
    {
        if(!Isoper(Exp_arry[i]) && Exp_arry[i] != '.' && !isdigit(Exp_arry[i]))
        return 1;
        if(isdigit(Exp_arry[i]))
        {
            int Dig_number=0,Cur_positoin=i+1;
            while(isdigit(Exp_arry[Cur_positoin]) || Exp_arry[Cur_positoin]=='.')
            {
                Dig_number++;
                Cur_positoin++;
            }
            if(Dig_number >= 16)//最多能夠計算15位有效數字 
            return 1;
        }
    }
    return 0;
}

void Evalua()
{//先調用Conver函數將字符串操作單元化，再調用Calculate函數計算結果並輸出 
    char Exp_arry[Expmax_length];
    int flag=0;//假設剛開始不合法，1表達式合法，0不合法 
    struct Ope_unit Opeunit_arry[Expmax_length];
    
    getchar();//吃掉一個換行符 
    printf("請輸入四則運算表達式，以=結尾：\n"); 
    gets(Exp_arry);
    flag=Check(Exp_arry);
    if(flag) 
    printf("該表達式不合法！\n");
    else
    {
        int Opeunit_count = Conver(Opeunit_arry,Exp_arry);
        double        ans = Calculate(Opeunit_arry,Opeunit_count,flag);
        if(flag)
        {
            printf("計算結果為：\n");
            printf("%s%lf\n",Exp_arry,ans);
        }
        else
        printf("該表達式不合法！\n");
    }
    system("pause"); 
}

int  Conver(struct Ope_unit Opeunit_arry[],char Exp_arry[])
{//將字符串操作單元化 
    int Explength=strlen(Exp_arry);
    int i,Opeunit_count=0;
    for(i=0;i<Explength;i++)
    {    
        if(Isoper(Exp_arry[i]))//是操作符 
        {
            Opeunit_arry[Opeunit_count].flag=0;
            Opeunit_arry[Opeunit_count++].oper=Exp_arry[i];
        }
        else//是操作數 
        {
            Opeunit_arry[Opeunit_count].flag=1;
            char temp[Expmax_length];
            int k=0;
            for(; isdigit(Exp_arry[i]) || Exp_arry[i]=='.' ;i++) 
            {
                temp[k++]=Exp_arry[i];
            }
            i--;
            temp[k]='\0';
            Opeunit_arry[Opeunit_count].real=atof(temp);//將字符轉化為浮點數
            
            //負數 
            if(Opeunit_count == 1 && Opeunit_arry[Opeunit_count-1].flag==0 
            && Opeunit_arry[Opeunit_count-1].oper=='-')
            {        
                Opeunit_arry[Opeunit_count-1].flag = -1; 
                Opeunit_arry[Opeunit_count].real  *= -1;
            }// -9 
            if(Opeunit_count >= 2 && Opeunit_arry[Opeunit_count-1].flag==0 
            && Opeunit_arry[Opeunit_count-1].oper=='-' && Opeunit_arry[Opeunit_count-2].flag==0 
            && Opeunit_arry[Opeunit_count-2].oper !=')')
            {        
                Opeunit_arry[Opeunit_count-1].flag = -1; 
                Opeunit_arry[Opeunit_count].real  *= -1;
            }// )-9
            
            //正數 
            if(Opeunit_count == 1 && Opeunit_arry[Opeunit_count-1].flag==0 
            && Opeunit_arry[Opeunit_count-1].oper=='+')
            {        
                Opeunit_arry[Opeunit_count-1].flag = -1; 
            }// +9 
            if(Opeunit_count >= 2 && Opeunit_arry[Opeunit_count-1].flag==0 
            && Opeunit_arry[Opeunit_count-1].oper=='+' && Opeunit_arry[Opeunit_count-2].flag==0 
            && Opeunit_arry[Opeunit_count-2].oper !=')')
            {        
                Opeunit_arry[Opeunit_count-1].flag = -1; 
            }// )+9
            Opeunit_count++;
        }
    }
    /*for(i=0;i<Opeunit_count;i++)
    {//查看各操作單元是否正確,1是操作數，0是操作符 
        if(Opeunit_arry[i].flag == 1)
        printf("該單元是操作數為：%lf\n",Opeunit_arry[i].real);
        else if(Opeunit_arry[i].flag == 0)
        printf("該單元是操作符為：%c\n",Opeunit_arry[i].oper);
        else
        printf("該單元是負號符為：%c\n",Opeunit_arry[i].oper);
    }*/
    return Opeunit_count;
} 

double Calculate(struct Ope_unit Opeunit_arry[],int Opeunit_count,int &flag)
{//根據運算規則，利用棧進行計算 
    int i,dS_pointer=0,oS_pointer=0;//dS_pointer為操作數棧頂指示器，oS_pointer為操作符棧頂指示器 
    double Dig_stack[Expmax_length];//操作數棧（順序存儲結構） 
    char   Ope_stack[Expmax_length];//操作符棧 
    
    for(i=0;i<Opeunit_count-1;i++)
    {
        if( Opeunit_arry[i].flag != -1 )
        {
            if(Opeunit_arry[i].flag)//是操作數 
            {
                Dig_stack[dS_pointer++]=Opeunit_arry[i].real;//入操作數棧 
                //printf("%lf\n",Digit[dS_pointer-1]);
            }
            else//是操作符 + - * / ( ) 
            {
                //操作符棧為空或者左括號 入棧
                if(oS_pointer==0 || Opeunit_arry[i].oper=='(')  
                {
                    Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;
                    //printf("%oS_pointer\Ope_u_count",Operator[oS_pointer-1]);
                }
                else
                {
                    if(Opeunit_arry[i].oper==')')//是右括號將運算符一直出棧，直到遇見左括號 
                    {
                        oS_pointer--;//指向棧頂 
                        dS_pointer--;//指向棧頂 
                        while(Ope_stack[oS_pointer] != '(' && oS_pointer != 0)
                        {
                            Dig_stack[dS_pointer-1] = Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer],
                            Ope_stack[oS_pointer--]);//oS_pointer--為操作符出棧 
                            
                            dS_pointer--;//前一個操作數出棧 
                            //printf("操作數棧頂元素等於%lf\n",Digit[dS_pointer]);
                        }
                        oS_pointer--;//左括號出棧
                         
                        oS_pointer++;//恢復指向棧頂之上 
                        dS_pointer++;
                    }
                    else if(Ope_Compar(Opeunit_arry[i].oper,Ope_stack[oS_pointer-1]))//和棧頂元素比較 
                     {
                         Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;
                         //printf("%oS_pointer\Ope_u_count",Operator[oS_pointer-1]);
                    } 
                     else//運算符出棧，再將該操作符入棧 
                     {
                         oS_pointer--;//指向棧頂 
                         dS_pointer--;//指向棧頂
                        while(Ope_Compar(Opeunit_arry[i].oper,Ope_stack[oS_pointer])==0 && oS_pointer != -1)
                        {//當前操作符比棧頂操作符優先級高 
                            Dig_stack[dS_pointer-1]=Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer],
                            Ope_stack[oS_pointer--]);
                            dS_pointer--;
                            //printf("操作數棧頂元素等於%lf\n",Digit[dS_pointer]);
                        }
                        oS_pointer++;//恢復指向棧頂之上  
                        dS_pointer++;
                        Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;
                    }
                } 
            }    
        }
    }
    /*for(i=0;i<oS_pointer;i++)
        printf("操作符棧%oS_pointer\Ope_u_count",Operator[i]);
    for(i=0;i<dS_pointer;i++)
        printf("操作數棧%lf\n",Digit[i]);*/
    oS_pointer--;//指向棧頂元素 
    dS_pointer--;//指向棧頂元素 
    while(oS_pointer != -1)
    {
        Dig_stack[dS_pointer-1]=Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer],
        Ope_stack[oS_pointer--]);//oS_pointer--為操作符出棧 
        dS_pointer--;//前一個操作數出棧 
        //printf("操作數棧頂元素為%lf\Ope_u_count",Digit[dS_pointer]);
    }
    //printf("%dS_pointer,%dS_pointer\n",oS_pointer,dS_pointer);
    if(oS_pointer==-1 && dS_pointer==0)
        flag=1;//為1表示表達式合法 
    return Dig_stack[0];
}

int  Ope_Compar(char ope1,char ope2)
{//操作符運算優先級比較
    char list[]={"(+-*/"};
    int map[5][5]={//先行后列，行比列的運算級優先級低為0，高為1 
    //        ( + - * /    
    /*  (  */ 1,0,0,0,0,
    /*  +  */ 1,0,0,0,0,
    /*  -  */ 1,0,0,0,0,
    /*  *  */ 1,1,1,0,0,
    /*  /  */ 1,1,1,0,0 };
    int i,j;
    for(i=0;i<5;i++) 
        if(ope1==list[i]) break;
    for(j=0;j<5;j++) 
        if(ope2==list[j]) break;
    return map[i][j];
}

double Four_arithm(double x,double y,char oper)
{//四則運算 
    switch(oper)//保證不含其它運算符 
    {
        case '+': return x+y;
        case '-': return x-y;
        case '*': return x*y;
        case '/': return x/y;//y不能為0 
        default : return 0; 
    }
}

int  Isoper(char ch)
{//判斷合法字符  + - * / ( ) =
    if(ch=='+' || ch=='-' || ch=='*' || ch=='/' || ch=='(' || ch==')' || ch=='=') 
        return 1;
    return 0;
}

void Display()
{//打印菜單 
    system("cls");
    printf("/******************************************************************************/\n");
    printf("\t\t       歡迎使用本四則運算表達式求值系統\n");
    printf("\n\t說明：建議請您先閱讀使用說明，再輸入相應的數字進行操作，謝謝配合！\n"); 
    printf("\n\t\t1 四則運算表達式求值\n"); 
    printf("\n\t\t2 使用說明\n");
    printf("\n\t\t0 退出\n"); 
    printf("/******************************************************************************/\n");
}

void Instru()
{//打印使用說明 
    FILE *fp;
    char ch;
    if( ( fp=fopen("使用說明.txt","r") ) == NULL)
    {
        printf("文件打開失敗！\n");
        exit(0); 
    } 
    for(; (ch = fgetc(fp)) != EOF; )
        putchar(ch);
    fclose(fp);
    printf("\n");
    system("pause"); 
}