栈的表达式求值应用，中缀转后缀

程序可以运行，但实现不了表达式求值的功能，问题出在哪里？

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

using namespace std;
#define N 1000

char infix[N];  //中缀表达式（未分离，都在一个字符串里）
char expression[N][10]; //保存预处理过的表达式，也就是每个元素都分离过的表达式
char suffix[N][10];     //保存后缀表达式的操作数
int count;//表达式中元素的个数（一个完整到数字（可能不止一位数）或者符号）
int suffixLength;//后缀表达式的长度

int level(char a){
    switch(a){
    case '#':return 0;
    case '+':
    case '-':return 1;
    case '*':
    case '/':return 2;
    case '^':return 3;
    default:break;
    }
    return -1;
}

int isDigital(char x){
    if( (x>='0'&&x<='9') || (x>='A'&&x<='Z') || (x>='a'&&x<='z') || (x=='.') )
            return 1;
    return 0;
}

int isNumber(char *str){
    int i;
    for(i=0;str[i];i++){
        if(isDigital(str[i])==0)return 0;
    }
    return 1;
}
/*************************************
预处理中缀表达式，把连续的字符分离成不同的元素，用字符串数组（expression[][]）
保存，方便后面的计算，因为这里考虑了运算数可能不全是个位数
比如：（12+3）
在处理成后缀表达式时，是123+，容易产生歧义（1+23 ? 12+3）
*************************************/
void pretreatment(char *str){
    int i,j,numberFlag;
    char temp[3];
    char number[10];
    count=0;
    numberFlag=0;
    for(j=0,i=0;str[i];i++){
        if(isDigital(str[i])==0){
            if(numberFlag==1){
                number[j]=0;
                strcpy(expression[count++],number);
                j=0;
                numberFlag=0;
            }
            if(str[i]!=' '){
                temp[0]=str[i];temp[1]=0;
                strcpy(expression[count++],temp);
            }
        }
        else {
            numberFlag=1;
            number[j++]=str[i];
        }
    }

    puts("分离后的表达式为");
    for(i=0;i<count;i++){
        printf("%s ",expression[i]);
    }puts("");
    puts("");
}
/*****************************************
中缀表达式 转 后缀表达式

遍历字符串，对于str[i]
str[i]是运算数（或者是字母代替的运算变量）输出；
str[i]是符号，有两种情况
(1)，是右括号，栈顶元素输出，直到与str[i]匹配的左括号出栈（左括号不用输出打印）
(2)，是运算符，判断str[i]与栈顶元素的优先级，str[i]优先级 不高于 栈顶符号，则栈
    顶元素输出，直到栈空 或者 栈顶符号优先级低于str[i]
*****************************************/
void infix_to_suffix(char str[N][10]){

    memset(suffix,0,sizeof(suffix));
    suffixLength=0;

    stack <char*> st;
    int i=0;
    char Mark[2]="#";
    st.push(Mark);
    do{
        if(isNumber(str[i])==1)//运算数直接保存到后缀表达式中
            strcpy(suffix[suffixLength++],str[i]);
        else if(str[i][0]=='(')        //是 左括号，直接入栈
            st.push(str[i]);
        else if(str[i][0]==')'){        //是 右括号，栈顶出栈，直到与其匹配的左括号出栈
            while( strcmp(st.top(),"(")!=0 ){
                char temp[10];
                strcpy(temp,st.top());
                strcpy(suffix[suffixLength++],temp);
                st.pop();
            }
            st.pop();
        }
        else if( strcmp(st.top(),"(")==0 )//是 运算符，且栈顶是左括号，则该运算符直接入栈
            st.push(str[i]);
        else {                    //是 运算符，且栈顶元素优先级不小于运算符，则栈顶元素一直
                                //出栈，直到 栈空 或者 遇到一个优先级低于该运算符的元素
            while( !st.empty() ){
                char temp[10];
                strcpy(temp,st.top());
                if( level(str[i][0]) > level(temp[0]) )
                    break;
                strcpy(suffix[suffixLength++],temp);
                st.pop();
            }
            st.push(str[i]);
        }
        i++;
    }while(str[i][0]!=0);

    while( strcmp(st.top(),"#")!=0 ){        //将栈取空结束
        char temp[10];
        strcpy(temp,st.top());
        strcpy(suffix[suffixLength++],temp);
        st.pop();
    }

    puts("后缀表达式为：");
    for(i=0;i<suffixLength;i++){
        printf("%s",suffix[i]);
    }puts("");
    puts("");
}

/**************************************
计算后缀表达式的值
**************************************/
char kt[N][10];
int stackTop;
void getResult(char str[N][10]){
    stackTop=0;
    /*这里要注意，内存的分配方案导致 i 的位置就在temp[9]旁边，然后strcpy()函数直接拷贝内存的话，在temp越界情况下会覆盖 i 的值*/
    int i;
    char temp[10];
    for(i=0;i<suffixLength;i++){
        if(isNumber(str[i])==1){
            strcpy(kt[stackTop++],str[i]);
        }
        else {
            char a[10],b[10];
            double na,nb,nc;

            strcpy(a,kt[stackTop-1]);
            na = atof(a);
            stackTop--;

            strcpy(b,kt[stackTop-1]);
            nb = atof(b);
            stackTop--;

            if(str[i][0]=='+')nc=nb+na;
            else if(str[i][0]=='-')nc=nb-na;
            else if(str[i][0]=='*')nc=nb*na;
            else if(str[i][0]=='/')nc=nb/na;

            sprintf(temp,"%lf",nc);
            strcpy(kt[stackTop++],temp);
        }
    }
    puts("计算出后缀表达式的结果：");
    printf("%s\n",kt[stackTop-1]);
}
int main(){
    char temp[N];
    while(gets(infix)){
        strcpy(temp,infix);
        pretreatment( strcat(temp," ") );
        infix_to_suffix(expression);
        getResult(suffix);
    }
    return 0;
}

前言

栈的一个广泛应用就是讲中缀表达式转换为后缀表达式。所谓中缀表达式就是我们从小到大所接触的：10+3-6/2+4*5 之类的算数表达式。而后缀表达式又称为逆波兰表达式，
它是由波兰逻辑学家J.Lukasiewicz于1929年提出的。

为什么需要后缀表达式

对于计算机而言，后缀表达式非常方便进行运算。举例来说，对于 "3,......
答案就在这里：栈的应用之中缀表达式转后缀
----------------------你好，人类，我是来自CSDN星球的问答机器人小C，以上是依据我对问题的理解给出的答案，如果解决了你的问题，望采纳。

你这个贴的图片，别人没法帮你调试。
代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。
提醒：再牛×的老师也无法代替学生自己领悟和上厕所！
单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。