中綴表達式求值

所用知識：C語言，堆棧操作

算法思想來自慕課浙江大學《數據結構》陳老師，何老師

筆記：

1.堆棧：
    1.1 引子    
        一種數據結構，在函數調用，表達式求值等都有廣泛的應用
        中綴表達式：a+b*c-d/e:生活中經常使用，但是計算機不好識別
        后綴表達式：abc*+dc/-:生活中不好使用，但計算機容易識別

        例：
        總結：因此需要一種存儲方法，能順序的存儲運算數，在需要時倒敘輸出。-->堆棧有
        堆棧的特點：后入先出。

    1.2堆棧的操作
    操作集：長度為maxSize的堆棧S ==> stack,堆棧的元素elementType，那么如下的操作
        stack createStack(int maxSize);//生成空堆棧，其最大長度為maxSize
        int isFull(stack s,int maxSize);//判斷棧s是否為空
        void push(stack  s,elementType item);//將元素壓入堆棧
        int isEmpty(stack s);//判斷堆棧是否為空
        elementType pop(stack s);//刪除並返回棧頂元素
        
        1.2.1
            用數組來表示堆棧的方法可以參照文件夾下面的同級目錄的文件stackArray.c
            同時還有使用一個數組來表示兩個堆棧，twoStack.c
        
        1.2.2使用鏈表來模擬堆棧
            因為鏈表有兩頭，但是堆棧的頭指針我們會選擇鏈表的頭節點，因為便於刪除操作，尾節點不方便進行刪除操作
            下面是模擬的示意圖
                head(頭指針，沒有元素的) --> node1(top指針) --> node2(堆棧中的元素) --> node3 --> node4
            代碼可以見：stackLinkList.c

        1.2.3 利用堆棧進行表達式求值
            我們平時所見到的表達式都是中綴表達式，但是如果想求表達式的值，先把中綴表達着中文后綴表達式，
            在利用堆棧對后綴表達式進行求值

            中綴表達式轉后綴表達式的思路；
                首先看一個簡單的：
                中綴表達式：2 + 9 / 3 - 5    后綴表達式：2 9 3 / + 5 -

                通過對比我們發現，中綴表達式和后綴表達式的數字順序並沒有發生改變，只是符號位置發生了改變
                所以，我們可以構思，使用一個棧來存在運算符，遇到數字就輸出，遇到符號就壓棧，如果讀入的符號比棧頂的符號
                優先級高，就壓棧，否則就彈棧並輸出
                下面是中綴表達式：2 + 9 / 3 - 5壓棧和彈棧的具體步驟
                輸出        堆棧內元素
                2           
                           +
                9           
                           /(優先級比+高，壓棧)
                3           
                / +           -(首先彈出/,但是因為同級運行需要按照從左往右的運算，所以+也需要彈棧)
                5           -
                -          (元素全部讀取完畢以后，-彈棧)

                所以中綴表達式：2 + 9 / 3 - 5的后綴表達式為 2 9 3 / + 5 -

                但是如果遇到帶有()的表達式怎么辦：遇到"("把"("壓入棧中，此時棧中的"("運算級別最低，在按照上面的運算符的運算規則來
                進行壓棧和彈棧。直到讀取到")",才把"("彈棧，但是對"("和")"不進行輸出

                舉個例子：
                求下面中綴表達式：2 * (9+6/3-5)+4的后綴表達式

                輸出            堆棧內元素(top->bottom)

                2
                                 *
                                 ( *
                9                 + ( *
                6            
                                 / + ( *
                3                 
                                 - ( *(首先彈出/,但是因為同級運行需要按照從左往右的運算，所以+也需要彈棧,並輸出)
                    / +
                5
                -                *(遇到")",把棧里依次彈出，直到遇到第一個"(",但是對"("和")"不進行輸出)
                *                +(遇到+，先彈出*，然后輸出)
                4                +
                +                NULL(沒有元素可讀，彈出堆棧中最后一個元素)
                
                所以中綴表達式：2 * (9+6/3-5)+4的后綴表達式為: 2 9 6 3 / + 5 - * 4 +

代碼實現

思路：中綴表達式先轉后綴表達式在求值

只支持0-9之間的數字的+-*/以及(),支持括號里面嵌套括號，如3*(2*3-4*1+(3*5)/3)*3+2

不支持分開的括號3*(2*3-4*1+(3*5)/3)*3+2+(4/2)

如果有給出修改意見，感激不盡。寫的比較匆忙，代碼的復用性和注釋的完整性可能不是很好

 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<ctype.h>
#define MAXSIZE 100


#include<stdio.h>
#include<stdlib.h>
/*使用鏈表來模擬堆棧，*/



/*=======================================================定義double類型的堆棧鏈式存儲並進行相關的壓棧，彈棧等操作===============================================================*/

//定義double類型的堆棧的鏈式存儲
typedef struct node3{
    double element;
    struct node3 *next;
}integerSta,*pIntegerStack;

//構造一個double類型的鏈式棧
pIntegerStack createIntegerEmptyStack(){
    pIntegerStack stack;
    stack = (pIntegerStack)malloc(sizeof(integerSta));
    if(stack){
        stack->next=NULL;
    }
    return stack;
}

//判斷double類型的鏈式棧是否為空
int isIntegerEmpty(pIntegerStack stack){
    if(stack->next==NULL){
        return 1;
    }else{
        return 0;
    }
}

//壓棧
void pushInteger(pIntegerStack stack,double element){
    pIntegerStack node = (pIntegerStack)malloc(sizeof(integerSta));
    node->element=element;
    node->next=stack->next;
    stack->next=node;
}

//彈棧
double popInteger(pIntegerStack stack){
    double element;
    pIntegerStack topHead;
    if(isEmpty(stack)){
        printf("the stack is empty,can not pop");
        return;
    }else{
        topHead = stack->next;
        stack->next = topHead->next;
        element = topHead->element;
        free(topHead);
        return element;
    }
}

//取棧頂元素
double getIntegetStackTopElement(pIntegerStack stack){
    return (stack->next->element);
}

//打印棧內元素
void toStringInteger(pIntegerStack stack){
    pIntegerStack top = stack->next;
    printf("toString:");
    while(top!=NULL){
        printf("%f ",top->element);
        top=top->next;
    }
    printf("\n");
}




/*================================================定義一個存儲字符的線性表=========================================================================*/



//構造一個線性表存儲后綴表達式
typedef struct node2{
    char data[MAXSIZE];
    int length;
}li,*pList;



//初始化線性表
pList createEmptyList(){
    pList p;
    p = (pList)malloc(sizeof(li));
    if(p){
        p->length=-1;
    }
    return p;
}

//向線性表中插入元素
void insert(pList list,char c){
    if(list){
        list->data[++(list->length)]=c;
    }
}

//將線性表中的元素打印
void toStringList(pList list){
    int i;
    for(i=0;i<=list->length;i++){
        printf("%c ",list->data[i]);
    }
    printf("\n");

}



/*==================================================定義一個字符棧並進行相關操作=================================================================*/
//定義字符棧
typedef struct node{
    char element;
    struct node *next;
}sta,*pStack;

//創建一個空的字符鏈式棧
pStack createEmptyStack(){
    pStack stack;
    stack = (pStack)malloc(sizeof(sta));
    if(stack){
        stack->next=NULL;
    }
    return stack;
}

//判斷鏈式棧是否為空
int isEmpty(pStack stack){
    if(stack->next==NULL){
        return 1;
    }else{
        return 0;
    }
}

//把元素壓入棧
void push(pStack stack,char element){
    pStack node = (pStack)malloc(sizeof(sta));
    node->element=element;
    node->next=stack->next;
    stack->next=node;
}

//把元素彈棧
char pop(pStack stack){
    char element;
    pStack topHead;
    if(isEmpty(stack)){
        printf("the stack is empty,can not pop");
        return NULL;
    }else{
        topHead = stack->next;
        stack->next = topHead->next;
        element = topHead->element;
        free(topHead);
        return element;
    }
}

//獲取棧頂元素
char getTopElement(pStack stack){
    if(isEmpty(stack)){
        printf("the stack is empty,can not get top element");
        return;
    }else{
        return (stack->next->element);
    }
}



/*=============================================中綴表達式轉后綴表達式=====================================================================*/


//打印字符數組
void charArrayToString(char *arr){
    char *p  = arr;
    while(*p!='\0'){
        printf("%c ",*p);
        p = p+1;
    }
}



/*
判斷字符c是否存在字符數組arr中
存在，返回1
不存在，返回0
*/
int isCharArrContainChar(char arr[],char c){
    char *p =arr;
    while(*p!='\0'){
        if(*p==c){
            return 1;
        }
        p = p+1;
    }
    return 0;
}


/*給定一個運算符，判斷他的優先級，返回數字越大，優先級越高，例如
    operatorPriorityArr是一個二維數組，下面是模擬的內容，優先級用戶可以自定義，數組按元素優先級由低到高排列
        0 +-    第0優先級
        1 * /   第1優先級
        2 ()    第2優先級

    c:等待判斷優先級的運算符
*/
int getCharIndex(char c,char operatorPriorityArr[][MAXSIZE],int length){
    int i;
    for(i=0;i<length;i++){
        if(isCharArrContainChar(operatorPriorityArr[i],c)){
            return i;
        }
    }
    return -1;
}


/*
判斷字符棧的棧頂元素的優先級和讀入字符的優先級
參數：
    stackTopEle：棧頂元素
    readChar：讀入的元素
    operatorPriorityArr：用戶自定義的運算符優先級二維字符數組，數組按元素優先級由低到高排列
    length:二維數組的行數

比較規則：
    1.如果讀入的字符為"(",那么"("的優先級最高，直接壓棧
    2.如果棧頂元素為"(",其優先級最低，eadChar直接入棧
    3.如果讀入的元素readChar優先級大於棧頂元素，則readChar入棧。例如eadChar為"*" topChar為"+",則"*"入棧
    4.如果讀入的元素readChar優先級小於或者等於(因為運算需要按照從左往右的順序)棧頂元素，則topChar彈棧並輸出(記錄)。
        再次判斷readChar和當前棧頂元素的優先級，如果當readChar還是優先級小於或者等於當前棧頂元素，接着彈棧並輸出(記錄)。
        一直比較，直到readChar的優先級大於棧頂元素或者棧為空。
    5.如果readChar為")"，一直彈棧到到第一次遇到"(",並把"("也彈棧，對"("和")"不做輸出，其運算符彈棧且輸出(記錄)

        返回值：
            1：壓棧
            0：讀入")" 直到把第一個"("彈棧棧為止
            2：彈出當前的棧頂元素，並繼續比較
*/
int compareOperatorChar(char stackTopEle,char readChar,char operatorPriorityArr[][MAXSIZE],int length){
    int index1,index2;
    if(stackTopEle=='('){
        return 1;//棧為空，直接壓棧
    }else if(readChar==')'){
        return 0;//讀入遇到")",直到把第一個"("彈棧棧為止
    }else{
        //獲取兩個運算符的優先級
        index1 = getCharIndex(stackTopEle,operatorPriorityArr,length);
        index2 = getCharIndex(readChar,operatorPriorityArr,length);
        if(index1<index2){//比較優先級
            return 1;
        }else{
            return 2;
        }
    }
}


/*
根據優先級的返回結果進行對應的壓棧和彈棧操作
參數：
    stack:准備好的空字符棧
    readChar：讀入的字符
    operatorPriorityArr:定義的優先級規則
    list：儲存后綴表達式的字符線性表
    length：二維數組的行數
*/
void comparePriority(pStack stack,char readChar,char operatorPriorityArr[][MAXSIZE],pList list,int length){
    if(isEmpty(stack)){
        push(stack,readChar);
        return 1;
    }else{
        char topEle = getTopElement(stack);
        int result = compareOperatorChar(topEle,readChar,operatorPriorityArr,length);
        if(result==0){
            while(getTopElement(stack)!='('){
                insert(list,pop(stack));
            }
            pop(stack);
            return;
        }else if(result==1){
            push(stack,readChar);
            return;
        }else{
            insert(list,pop(stack));
            //遞歸再次比較
            comparePriority(stack,readChar,operatorPriorityArr,list,length);
        }
    }
}


/*
根據中綴表達式或者后綴表達式，轉換規則：
    1.對於數字，進行原樣的輸出或者記錄
    2.對於運算符，根據優先級進行壓棧彈棧操作，優先級比較規則參照上面
參數：
    stack:准備好的空字符棧
    arr：中綴表達式的字符數組，支持空格隔開
    operatorPriorityArr:定義的優先級規則
    list：儲存后綴表達式的字符線性表
    length：二維數組的行數
*/
char* getBehindExpress(pStack stack,char *arr,char operatorPriorityArr[3][MAXSIZE],pList list,int length){
    char *p  = arr;
    while(*p!='\0'){
        if(*p>='0' && *p<='9'){
            insert(list,*p);
        }else if(*p==' '){
            p = p+1;
            continue;
        }else if(getCharIndex(*p,operatorPriorityArr,length)!=-1){//判斷運算符是否和法
                comparePriority(stack,*p,operatorPriorityArr,list,length);
        }else{
            printf("the operational character is illegal\n");
            return "error";
        }
        p = p+1;
    }
    //當數字讀取完畢后，要把棧里面的運算符全部彈棧
    while(!isEmpty(stack)){
        insert(list,pop(stack));
    }
}

//打印字符棧里面的元素
void toString(pStack stack){
    pStack top = stack->next;
    printf("toString:");
    while(top!=NULL){
        printf("%c ",top->element);
        top=top->next;
    }
    printf("\n");
}




/*==================================================計算后綴表達式的值==========================================================================*/
/*計算規則如下：
求后綴表達式的值
            6 2 / 3 - 4 2 * + =

            后綴表達式的求解原理：遇到數值先記錄(壓棧)，遇到符號才計算(彈棧兩個元素)。計算離符號最近的兩個數
            1.6 2 / ==> 3 壓棧
            2.3 3 - ==> 0 壓棧
            3.0 4 2 * ==> 0 8
            4.0 8 + ==>8
            5.8 = ==> 8
*/
double getValueByAfterExpress(pList list,pStack stack){
    int i,store;
    double temp,a1,a2;
    for(i=0;i<=list->length;i++){
        //printf("test");
        char c = list->data[i];
        if(c>='0' && c<='9'){
            store = c-'0';//字符轉換為數字
            temp = store*1.0;//整形轉換為double型
            //printf("double:%f\n",temp);
            pushInteger(stack,temp);//數字就壓棧
        }else{
            //彈棧並根據運算符做運算
            double a1 = popInteger(stack);
            double a2 = popInteger(stack);
            if(list->data[i]=='+'){
                temp = a1+a2;
                pushInteger(stack,temp);
            }

            if(list->data[i]=='-'){
                temp = a2-a1;
                pushInteger(stack,temp);
            }
            if(list->data[i]=='*'){
                temp = a1*a2;
                pushInteger(stack,temp);
            }
            if(list->data[i]=='/'){
                temp = a2/a1;
                pushInteger(stack,temp);
            }

        }
        //toStringInteger(stack);
    }
    //最終的棧頂元素即為所求的值
    return getIntegetStackTopElement(stack);
}



void main(){
    int n = 3,i;
    pStack stack  = createEmptyStack();
    pStack numberStack   = createIntegerEmptyStack();
    pList list = createEmptyList();

    char arr1[] = "2 * ( 9 + 6 / 3 - 5 ) + 4";
    char arr2[] = "2 + 9 / 3 - 5";
    char arr3[] = "3*(2*3-4*1+(3*5)/3)*3+2";
    char operatorPriorityArr[3][MAXSIZE]={"+-","*/","()"};
    //計算二維數組的行數
    int length=sizeof(operatorPriorityArr)/sizeof(operatorPriorityArr[0]);
    //char operatorArr[] = "+-*/()";
    getBehindExpress(stack,arr3,operatorPriorityArr,list,length);
    //toStringList(list);
    double value = getValueByAfterExpress(list,numberStack);
    printf("the express %s caculate result is %f",arr3,value);
    //double c = (double)('9.23');
    //printf("test:%f",c);
    //printf("%d",length);
}