中綴表達式轉後綴表達式

算法

遍歷中綴表達式中的數字和符號：
    對於數字直接輸出
    對於符號：
        左括號：進棧
        運算符號：與棧頂符號進行優先級比較
            若棧頂符號優先級低：此符號進棧
                （默認棧頂如果左括號，左括號優先級最低）
            若棧頂符號優先級不低：棧頂符號彈出並輸出，以後進棧
            右括號： 將棧頂符號彈出並輸出，直到匹配左括號
遍歷結束：將棧中的全部符號彈出並輸出

#ifndef LINKSTACK_H_INCLUDED
#define LINKSTACK_H_INCLUDED

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

//鏈式棧的結點
typedef struct LINKNODE {
    struct LINKNODE *next;
}LinkNode;


//鏈式棧
typedef struct LINKSTACK {
    LinkNode head;
    int size;
}LinkStack;

//初始化函數
LinkStack *Init_LinkStack();

//入棧
void Push_LinkStack(LinkStack *stack, LinkNode *data);

//出棧
void Pop_LinkStack(LinkStack *stack);

//返回棧頂元素
LinkNode* Top_LinkStack(LinkStack *stack);

//返回棧元素的個數
int Size_LinkStack(LinkStack *stack);

//清空棧
void Clear_LinkStack(LinkStack *stack);

//銷燬
void FreeSpace_LinkStack(LinkStack *stack);


#endif // LINKSTACK_H_INCLUDED

#include "LinkStack.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//初始化函數
LinkStack *Init_LinkStack() {
    LinkStack *stack = (LinkStack *)malloc(sizeof(LinkStack));
    stack->head.next = NULL;
    stack->size = 0;
    return stack;
}

//入棧
void Push_LinkStack(LinkStack *stack, LinkNode *data) {
    if(stack == NULL){
        return;
    }
    if(data == NULL){
        return;
    }
    data->next = stack->head.next;
    stack->head.next = data;
    stack->size++;
}

//出棧
void Pop_LinkStack(LinkStack *stack) {
    if(stack == NULL){
        return;
    }
    if(stack->size == 0){
        return;
    }

    //第一個有效結點
    LinkNode *pNext = stack->head.next;
    stack->head.next = pNext->next;
    stack->size--;
}

//返回棧頂元素
LinkNode* Top_LinkStack(LinkStack *stack) {
    if(stack == NULL){
        return NULL;
    }
    if(stack->size == 0){
        return NULL;
    }
    //返回頭結點後面的第一個元素
    return stack->head.next;
}

//返回棧元素的個數
int Size_LinkStack(LinkStack *stack) {
    if(stack == NULL){
        return 0;
    }
    return stack->size;
}

//清空棧
void Clear_LinkStack(LinkStack *stack) {
    if(stack == NULL){
        return;
    }
    stack->head.next = NULL;
    stack->size = 0;
}

//銷燬
void FreeSpace_LinkStack(LinkStack *stack) {
    if(stack == NULL) {
        return;
    }
    free(stack);

}

/*
 * main.c
 *
 *  Created on: 2019年8月14日
 *      Author: Administrator
 */


#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "LinkStack.h"

//判斷是不是數字
int IsNumber(char c) {
    return c >= '0' && c <= '9';
}

void NumberOperate(char *p) {
    printf("%c", *p);
}

//判斷是否是左括號
int IsLeftBracket(char c){
    return c=='(';
}
int IsRightBracket(char c){
    return c==')';
}

//判斷是否是運算符號
int IsOperator(char c) {
    return c == '+' || c == '-' || c=='*' || c == '/';
}

//返回運算符號優先級
int GetPriority(char c) {
    if(c == '*' || c == '/') {
        return 2;
    }
    if(c == '+' || c == '-') {
        return 1;
    }

    return 0;
}

////數字操做
//void NumberOperate (char *p) {
//  printf('%c', *p);
//}



typedef struct MYCHAR {
    LinkNode Node;
    char *p;
}MyChar;

//建立MyChar
MyChar *CreateMyChar(char *p) {
    MyChar *myChar = (MyChar *)malloc(sizeof(MyChar));
    myChar->p = p;
    return myChar;
}



//左括號的操做
void LeftOperate(LinkStack *stack, char *p) {
    Push_LinkStack(stack, (LinkNode *)CreateMyChar(p));
}

void RightOperate(LinkStack *stack, char *p) {
    //先判斷棧中有沒有元素
    while(Size_LinkStack(stack) > 0){
        MyChar *mychar = (MyChar *)Top_LinkStack(stack);
        if(IsLeftBracket(*(mychar->p))){
            Pop_LinkStack(stack);
            break;
        }
        //輸出
        printf("%c",*(mychar->p));
        //彈出
        Pop_LinkStack(stack);
        //釋放內存
        free(mychar);
    }
}

//運算符號操做
void OperatorOperate(LinkStack *stack, char *p) {


    //先取出棧頂符號
    MyChar *mychar = (MyChar *)Top_LinkStack(stack);
    if(mychar == NULL) {
        Push_LinkStack(stack, (LinkNode *)CreateMyChar(p));
        return;
    }
    //若是棧頂元素優先級低於當前字符的優先級， 直接入棧
    if(GetPriority(*(mychar->p)) < GetPriority(*p)) {
        Push_LinkStack(stack, (LinkNode *)CreateMyChar(p));
        return;
    }else {
        //若是棧頂符號優先級不低
        while(Size_LinkStack(stack) > 0) {
            MyChar *mychar2 = (MyChar *)Top_LinkStack(stack);
            //若是優先級低的 當前符號入棧
            if(GetPriority(*(mychar2->p)) < GetPriority(*p)) {
                Push_LinkStack(stack, (LinkNode *)CreateMyChar(p));
                break;
            }
            //輸出
            printf("%c", *(mychar2->p));
            //彈出
            Pop_LinkStack(stack);
            //釋放
            free(mychar2);
        }
    }
}

int main() {
    char *str = "8+(3-1)*5";
    printf("%s\n",str);
    char *p = str;

    //建立棧
    LinkStack *stack = Init_LinkStack();

    while (*p != '0'){
        //若是是數字
        if(IsNumber(*p)){
            NumberOperate(p);
        }

        //若是是左括號，直接進棧
        if(IsLeftBracket(*p)){
            LeftOperate(stack, p);
        }

        //若是是右括號
        if(IsRightBracket(*p)){
            RightOperate(stack, p);
        }

        if(IsOperator(*p)) {
            OperatorOperate(stack, p);
        }
        p++;
    }

    system("pause");
    return 0;
}

輸出結果

請按任意鍵繼續. . . 

8+(3-1)*5
831-5*+1