逆波兰中缀转后缀代码

RH.h

#ifndef    _MRCHEN_RP_H_
#define    _MRCHEN_RP_H_
#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"
#include "string.h"
#include "iostream"
#include <stack>
using    namespace    std;
#ifndef    __cplusplus
    typedef    int    BOOL;
    #ifndef    TRUE
    #define    TRUE    1
    #endif
    #ifndef    FALSE
    #define    FALSE    0
    #endif
#else
    typedef    bool    BOOL;
    #ifndef    TRUE
    #define    TRUE    true
    #endif
    #ifndef    FALSE
    #define    FALSE    false
    #endif
#endif

//用于子串连接的结构
typedef    struct    _tagSubExp{
    char        *exp_p;
    struct    _tagSubExp*next;
}SUB_EXP,*PSUB_EXP;

extern    stack<PSUB_EXP>    s1;//存放表达式
extern    stack<PSUB_EXP>    s2;//存放括号和运算符
/*子串出栈*/
BOOL        pop_exp(PSUB_EXP*,BOOL);
/*子串入栈*/
BOOL        push_exp(PSUB_EXP,BOOL);
/*合并三个子串*/
BOOL        cat_exp(PSUB_EXP,PSUB_EXP,PSUB_EXP);
/*一次获取中缀表达式中的子串*/
BOOL        get_next(PSUB_EXP*,char*);
/*获取中缀表达式*/
char    *     get_exp(char *exp_p);
/*将中缀表达式转换为后缀表达式*/
char    *     convert_exp(char    *exp,char    *convert_sz);
/*打印逆波兰表达式*/
void         print_exp(PSUB_EXP);

#endif

RH.cpp

// 逆波兰运算.cpp : Defines the entry point for the console application.
#include "stdafx.h"
#include "RP.h"

stack<PSUB_EXP>    s1;
stack<PSUB_EXP>    s2;

/*打印后缀表达式*/
void        print_exp(PSUB_EXP p)
{
    while(p){
        printf("%s  ",p->exp_p);
        p = p->next;
    }
    printf("\n");
}

/*将中缀表达式转换为后缀表达式*/
char    *    convert_exp(char    *exp,char    *convert_p)
{
    char    ch;
    PSUB_EXP    p;
    PSUB_EXP    sub_p;
    PSUB_EXP    f_p,  s_p,  t_p;
    //判断参数时候合法
    if(convert_p==NULL||exp==NULL || *exp == '\n'){
        return    NULL;
    }
    //循环读取中缀表达式
    while( TRUE==get_next(&sub_p,exp) ){
        //判断读取到的是数字串还是运算符还是括号
        ch = *(sub_p->exp_p);
        switch(ch){
            //如果是 + ， 则入栈
            case    '+':
            {
                push_exp(sub_p,FALSE);
            }
                break;
            //如果是 - ， 则入栈
            case    '-':
            {
                push_exp(sub_p,FALSE);
            }
                break;
            //如果是 * ， 则入栈
            case    '*':
            {
                //先入栈
                push_exp(sub_p,FALSE);
                //然后读取下个字串
                get_next(&sub_p,exp);
                //如果是数字串，这进行合并处理
                ch = *(sub_p->exp_p);
                if(ch >= '0' && ch <= '9' ){
                    s_p = sub_p;
                    pop_exp(&t_p,FALSE);
                    pop_exp(&f_p,TRUE);
                    cat_exp(f_p,s_p,t_p);
                    push_exp(f_p,TRUE);
                }else if(ch == '('){//如果是括号，则入栈
                    push_exp(sub_p,FALSE);
                }
            }
                break;
            case    '/':
            {
                //先入栈
                push_exp(sub_p,FALSE);
                //然后读取下个字串
                get_next(&sub_p,exp);
                //如果是数字串，这进行合并处理
                ch = *(sub_p->exp_p);
                if(ch >= '0' && ch <= '9' ){
                    s_p = sub_p;
                    pop_exp(&t_p,FALSE);
                    pop_exp(&f_p,TRUE);
                    cat_exp(f_p,s_p,t_p);
                    push_exp(f_p,TRUE);
                }else if(ch == '('){//如果是括号，则入栈
                    push_exp(sub_p,FALSE);
                }
            }
                break;
            case    '('://如果是前括号 则入栈
            {
                push_exp(sub_p,FALSE);
            }
                break;
            case    ')'://如果是否括号，这进行相应处理
            {
                //从栈中弹出两表达式串，一个运算符串，然后合并并押入栈中，直到弹出的运算符是 '('
                while(pop_exp(&t_p,FALSE)&&*(t_p->exp_p)!='('){
                    pop_exp(&s_p,TRUE);
                    pop_exp(&f_p,TRUE);
                    cat_exp(f_p,s_p,t_p);
                    push_exp(f_p,TRUE);
                }
                //接着弹出后续的运算符
                pop_exp(&t_p,FALSE);
                //如果是 *  或 / , 则再从栈中弹出两表达式，并合并 然后入栈
                if(*(t_p->exp_p)=='*'||*(t_p->exp_p)!='/'){
                    pop_exp(&s_p,TRUE);
                    pop_exp(&f_p,TRUE);
                    cat_exp(f_p,s_p,t_p);
                    push_exp(f_p,TRUE);
                }else{//如果不是 * 或 / , 则将运算符方入栈中
                    push_exp(t_p,FALSE);
                }
            }
                break;
            default:
            {//如果是数字串 ， 则 入栈
                push_exp(sub_p,TRUE);
            }
                break;
        }
    }
    //将栈中剩下的数据排列成后缀形式
    while(pop_exp(&t_p,FALSE)){
        pop_exp(&s_p,TRUE);
        pop_exp(&f_p,TRUE);
        cat_exp(f_p,s_p,t_p);
        push_exp(f_p,TRUE);
    }
    //将转换好的后缀表达式存放到新的空间中
    while(f_p){
        strcat(convert_p,f_p->exp_p);
        p = f_p;
        f_p = f_p->next;
        getchar();
        free(p);
    }
    return    convert_p;
}

/*获取中缀表达式*/
char*        get_exp(char *exp_p)
{
    char        tmp_exp_sz[64+1];
    char        *p = tmp_exp_sz;
    int         i;
    //输入中缀表达式
    fgets(p,64,stdin);
    //然后解析中缀表达式 ， 并以 '\0'分割每个子串
    for(i=0; *p!='\0' ; i++){
        if(*p >= '0' && *p <= '9'){
            exp_p[i] = *p;
        }else{
            if(*p != ' '){
                exp_p[i++] = NULL;
                exp_p[i++] = *p;
                exp_p[i]     = NULL;
            }
        }
        p++;
    }
    return    0;
}
/*一次获取中缀表达式中的子串*/
BOOL        get_next(PSUB_EXP * sub_p,char*exp_p)
{
    static     char    *p = exp_p;
    if(*p == '\n'){
        return    FALSE;
    }
    //申请保存串信息的节点
    *sub_p = (PSUB_EXP)calloc(1,sizeof(SUB_EXP));
    (*sub_p)->exp_p = p;
    //获取下一个串
    p += strlen(p);
    while(*(++p) == NULL);
    return    TRUE;
}

/*子串出栈*/
BOOL        pop_exp(PSUB_EXP* sub_pp,BOOL    flag)
{
    if(flag == TRUE){// 从s1栈中弹出表达式串
        if(s1.empty())
            return    FALSE;
        *sub_pp = (PSUB_EXP)s1.top();
        s1.pop();
    }else{//从s2中弹出运算符串
        if(s2.empty())
            return    FALSE;
        *sub_pp = (PSUB_EXP)s2.top();
        s2.pop();
    }
    return    TRUE;
}

/*子串入栈*/
BOOL        push_exp(PSUB_EXP sub_p,BOOL flag)
{
    if(flag == TRUE){//如果是表达式串则放入s1栈中
        s1.push(sub_p);
    }else{
        s2.push(sub_p);//如果是表达式串则放入s2栈中
    }
    return    TRUE;
}

/*合并三个子串*/
BOOL        cat_exp(PSUB_EXP f_p,PSUB_EXP s_p,PSUB_EXP t_p)
{
    PSUB_EXP    p;
    if(!f_p || !s_p || !t_p){
        return    FALSE;
    }else{
        //按 f_p:s_p:t_p 的顺序合并 
        p = f_p;
        while(p->next)
            p = p->next;
        p->next = s_p;
        p  = s_p;
        while(p->next)
            p = p->next;
        p->next = t_p;
    }
    return    TRUE;
}

main.cpp

// 逆波兰运算.cpp : Defines the entry point for the console application.
#include "stdafx.h"
#include "RP.h"
//9+20*(15-4)+7/8-6
int main(int argc, char* argv[])
{
    char        exp_sz[128+1] = {0};
    char        convert_sz[128+1] = {0};
    char        *p = exp_sz;
    get_exp(exp_sz);
    /*
    while( *p!= '\n'){
        puts(p);
        p += strlen(p);
        while(*(++p)==NULL);
    }
    */
    p = convert_exp(exp_sz , convert_sz);
    printf("%s\n",convert_sz);
    return 0;
}