C语言 中缀转后缀

给定字符串型的算术表达式，实现中缀转后缀并运算得出结果；

#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include"stack.h"
#define SIZE 100
#define TYPE char
typedef struct Node* pNode;
typedef struct Node node;
typedef pNode Stack;

char postfix[SIZE];

struct Node
{
    TYPE data;
    struct Node* next;
};
int isEmpty(Stack s);
void Pop(Stack s);
void Push(Stack s,TYPE element);
TYPE Top_of_stack(Stack s);
Stack CreatStack();
void makeEmpty(Stack s);

Stack CreatStack()
{
    Stack s=(Stack)malloc(sizeof(node));
    s->next=NULL;
    makeEmpty(s);
    return s;
}
void makeEmpty(Stack s)
{
    if(s==NULL)
    printf("you need creat a stack at first");
    while(!isEmpty(s))
    Pop(s);
}
int isEmpty(Stack s)
{
    return s->next==NULL;
}
void Pop(Stack s)
{
    if(isEmpty(s))
      printf("Stack is empty");
    else
    {
        pNode temp=s->next;
        s->next=s->next->next;
        free(temp);
    }

}
void Push(Stack s,TYPE element)
{
    pNode temp=(Stack)malloc(sizeof(node));
    if(temp)
    {
        temp->data=element;
        temp->next=s->next;
        s->next=temp;
    }
}
TYPE Top_of_stack(Stack s)
{
    if(isEmpty(s))
    {
        printf("Stack is empty");
        return 0;
    }
    else
    return s->next->data;
}


#endif // STACK_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#include"stack.h"
#define SIZE 100

char postfix[SIZE];

// if op > instack push else pop;
// return the priority of operator of  expression minus
//that of stack  栈外优先级减去栈内优先级
int priority(char op_of_expression,char ch_in_stack)
{
    int op=0;
    int ch=0;
    if(op_of_expression=='+'||op_of_expression=='-')
        op=1;
    else if(op_of_expression=='*'||op_of_expression=='/')
        op=2;
    else if(op_of_expression=='(')
        op=3;
    else
      printf("wrong operator");

    if(ch_in_stack=='+'||ch_in_stack=='-')
        ch=1;
    else if(ch_in_stack=='*'||ch_in_stack=='/')
        ch=2;
    else if(ch_in_stack=='(')
        ch=0;
    else
      printf("wrong operator");

      return op-ch;
}
int isOperator(char ch)
{
    switch (ch)
    {
        case'+':
        case'-':
        case'*':
        case'/':
        case'(':
        case')':
            return 1;
            break;
         default:
            return 0;
            break;
    }
}
void Infix_to_Pofix(char* s)
{
     int  index=0;

     char ch;
     Stack stack=CreatStack();
     makeEmpty(stack);
     while((ch=*s)!='')
     {
         if(!isOperator(ch))
         {
             postfix[index++]=ch;
             s++;
             if(isOperator(*s)||*s=='')
             postfix[index++]='_';
         }
         else
         {
             if(isEmpty(stack))
            {
                Push(stack,ch);
                s++;
                continue;
            }
            else
            {
                if(ch==')')
                {
                    while(!isEmpty(stack)&&Top_of_stack(stack)!='(')
                    {
                        postfix[index++]=Top_of_stack(stack);
                        Pop(stack);
                    }
                    Pop(stack);
                    s++;
                    continue;
                }
                else if(priority(ch,Top_of_stack(stack))>0)
                {
                    Push(stack,ch);
                    s++;
                    continue;
                }
                else
                {
                    while(!isEmpty(stack)&&priority(ch,Top_of_stack(stack))<=0)
                    {
                        postfix[index++]=Top_of_stack(stack);
                        Pop(stack);
                    }
                    Push(stack,ch);
                    s++;
                    continue;
                }
           // else if(priority(ch,Tops))
            }
         }

     }
     while(!isEmpty(stack))
     {
         postfix[index++]=Top_of_stack(stack);
         Pop(stack);
     }
    //postfix[index++]='';
}

int compute(char *str)
{
    #undef TYPE
    #define TYPE int
    Stack s=CreatStack();
    makeEmpty(s);
    int temp_int;
    while((*str)!='')
    {

        if(isdigit(*str))
        {
            Push(s,(int)atof(str));
            //printf("ss%d",(int)atof(str));
            while(((*str)!='_'))
            {
                str++;
            }
              str++;
        }
        else if(isOperator((*str)))
        {
            switch(*str)
            {
            case'*':
                temp_int=Top_of_stack(s);
                Pop(s);
                //printf("%d
",Top_of_stack(s));
                temp_int*=Top_of_stack(s);
                Pop(s);
                Push(s,temp_int);
                //printf("%d
",Top_of_stack(s));
                break;
            case'-':
                temp_int=Top_of_stack(s);
                Pop(s);
                //printf("%d
",Top_of_stack(s));
                temp_int=Top_of_stack(s)-temp_int;
                Pop(s);
                Push(s,temp_int);
                //printf("%d
",Top_of_stack(s));
                break;
            case'/':
                temp_int=Top_of_stack(s);
                Pop(s);
                //printf("%d
",Top_of_stack(s));
                temp_int=Top_of_stack(s)/temp_int;
                Pop(s);
                Push(s,temp_int);
                //printf("%d
",Top_of_stack(s));
                break;
            case'+':
                temp_int=Top_of_stack(s);
                Pop(s);
                //printf("%d
",Top_of_stack(s));
                temp_int+=Top_of_stack(s);
                Pop(s);
                Push(s,temp_int);
                //printf("%d
",Top_of_stack(s));
                break;
            default:
                printf("wrong");
                    break;
            }
            str++;
        }

    }
    return temp_int;
}


int main()
{
    char ch[]="10+(3*6-8)/2";
    Infix_to_Pofix(ch);
    printf("%s
",postfix);
    //postfix="134.4";
  //    printf("%d
",(int)atof("34_34*"));
    printf("result：%d
",compute(postfix));



  return 0;
}