程序代码：

#include<stdio.h>
#include<stdlib.h>
#include<string>
/*表达式求值
问题描述：使用键盘输入表达式，计算表达式的值并输出；
将表达式转化成后缀表达式输出，利用后缀表达式求表达式的值并输出。
测试数据：
3*（7-2）
2*（6+2*（3+6*（6+6）））+（6+6）*3+2
8/（9-9）
*/
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct{
    char *base;
    char *top;
    int stacksize;
}Sqstack;
typedef struct{
    int *base;
    int *top;
    int stacksize;
}Sqstack_int;

void InitStack (Sqstack &S){
    //创建一个空栈char型S
    S.base = (char *) malloc (STACK_INIT_SIZE * sizeof(char));
    if(!S.base) exit(-1);//申请内存失败
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
}
void InitStack_Int (Sqstack_int &S){
    //创建一个空栈int型S
    S.base = (int *) malloc (STACK_INIT_SIZE * sizeof(int));
    if(!S.base) exit (-1);//申请内存失败
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
}

int GetTop (Sqstack S,char &e){
    //若栈不为空，则用e返回S的栈顶元素，并返回1，否则返回0
    if(S.top==S.base) return 0;
    e=*(S.top-1);
    return 1;
}
int GetTop_Int (Sqstack_int S,int &e){
    //若栈不为空，则用e返回S的栈顶元素，并返回1，否则返回0
    if(S.top==S.base) return 0;
    e=*(S.top-1);
    return 1;
}

void Push_int(Sqstack_int &S,int e){
    //插入元素e作为新的栈顶元素
    if(S.top-S.base>=S.stacksize){//满栈，追加存储空间
        S.base = (int *) realloc (S.base,(S.stacksize+STACKINCREMENT) *sizeof(int));
        if(!S.base) exit (-1);//申请空间失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++=e;
}
void Push(Sqstack &S,int e){
    //插入元素e作为新的栈顶元素
    if(S.top-S.base>=S.stacksize){//满栈，追加存储空间
        S.base = (char *) realloc (S.base,(S.stacksize+STACKINCREMENT) *sizeof(char));
        if(!S.base) exit (-1);//申请空间失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++=e;
}

char Pop(Sqstack &S,char &e){
    //若栈不为空，则删除S的栈顶元素，并用e返回其值，并返回1，否则返回0
    if (S.top == S.base) printf("empty");
    e = *--S.top;
    return e;
}
int Pop_Int(Sqstack_int &S,int &e){
    //若栈不为空，则删除S的栈顶元素，并用e返回其值，并返回1，否则返回0
    if (S.top == S.base) printf("empty");
    e = *--S.top;
    return e;
}

int Output(char* c){
    char s;
    c++;
    s=*c;
    while(s!='#')  printf("%c",s);
    return 1;
}

char Precede(char c,char d){
    if (c=='('&&d==')') return '=';
    if (c==d) {
        if(c!='('&&c!='#') return '>';
        else return '=';
    }
    if (c=='*'||c=='/') {
        if(d=='(') return '<';
        else return '>';
    }
    if (c=='+'||c=='-') {
        if (d=='*'||d=='/'||d=='(') return '<';
        if (d=='+'||d=='-'||d==')'||d=='#') return '>';
    }
    if (c==')'&&d!='(') return '>';
    if ((c=='('&&d=='#')||(c==')'&&d=='(')||(c=='#'&&d==')')) return 0;
    if ((c=='('||c=='#')&&(d!=')')) return '<';
    return 0;
}

int Isopertor(char c){
    char *p="#/*+-";
    while(*p){
        if(*p==c)
            return 1;
        p++;
    }
    return 0;
}

char* Sort(char* p){
    Sqstack OPTR,OPRE; char c,e,x,l;
    InitStack(OPTR); Push(OPTR,'#');
    InitStack(OPRE); c=*p;
    while (c!='#'||(GetTop(OPRE,l)!=1)||l!='#'){
        if(!Isopertor(c)){
            Push(OPRE,c); p++;
            break;
        }
        else{
        GetTop(OPRE,l);
        switch(Precede(l,c)){
        case'<':
            Push(OPTR,c); p++;
            break;
        case'=':
            Pop(OPTR,x);p++;
            break;
        case'>':
            Pop(OPTR,e);
            Push(OPRE,e);
            break;
        }
        }
    }
    Push(OPTR,'#');
    return OPRE.base;
}

char Operator(char m,char n,char c){
    int a,b;char finall;
    a=atoi(&m);b=atoi(&n);
    int result;
    if(c=='+') result=a+b;
    if(c=='-') result=a-b;
    if(c=='*') result=a*b;
    if(c=='/') {
        if(b==0) {printf("分母不能为零"); return 0;}
        else result=a/b;
    }
    finall='0'+result;
    return finall;
}

char Evaluate(char *p){
    Sqstack OPTR,OPRE; char c,e,x,a,b;int l,m;
    InitStack(OPTR); Push(OPTR,'#');
    InitStack(OPRE); c=*p;
    while (c!='#'||GetTop(OPRE,c)!=0){
        if(!Isopertor(c)){
            Push(OPRE,c); p++;
            break;
        }
        else
        switch(Precede(GetTop(OPRE,e),c)){
        case'<':
            Push(OPTR,c); p++;
            break;
        case'=':
            Pop(OPTR,x);p++;
            break;
        case'>':
            Pop(OPTR,e);
            Pop(OPRE,b);Pop(OPRE,a);
            Push(OPRE,Operator(a,b,e));
            break;
        }
    }
    GetTop(OPRE,c);
    return c;
}
int Evaluate_P(char *p){
    Sqstack_int S; char a,a1,a2,k;int m,n,l;
    if(!Isopertor(*p)) {
        Push_int(S,atoi(p)); p++;
    }
    else {
        Pop_Int(S,n);Pop_Int(S,m);
        a=*p;
        a1='0'+m;a2='0'+n;
        k=Operator(a1,a2,a);
        l=atoi(&k);
        Push_int(S,l);
    }
    GetTop_Int(S,l);
    return l;
}

int main(){
    char *p;char *l;
    printf("请输入表达式以#结束：");
    gets(p);
    printf("表达式求值：");
    puts(p);
    printf("=%s\n",Evaluate(p));
    printf("\n");
    printf("后缀表达式:");
    l=Sort(p);
    Output(l);
    printf("=");
    Evaluate_P(l);
    return 0;
}