中缀表达式转后缀表达式

算法

遍历中缀表达式中的数字和符号：
    对于数字直接输出
    对于符号：
        左括号：进栈
        运算符号：与栈顶符号进行优先级比较
            若栈顶符号优先级低：此符号进栈
                （默认栈顶如果左括号，左括号优先级最低）
            若栈顶符号优先级不低：栈顶符号弹出并输出，以后进栈
            右括号： 将栈顶符号弹出并输出，直到匹配左括号
遍历结束：将栈中的全部符号弹出并输出

#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