数据结构，C语言实现四则运算

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include "assert.h"

struct element
{
    int data;
    char ch;
    struct element *next;
};

#define CHARSTACKSIZE 256
char charstack[CHARSTACKSIZE];
int  top = -1;

#define INTSTACKSIZE 256
char intstack[INTSTACKSIZE];
int  int_top = -1;

int charstackIsFull( void )
{
    if( top==(CHARSTACKSIZE-1) )
    {
        printf("charstack is full/n");
        return 1;
    }
    else
    {
        return 0;
    }
}

int charstackIsEmpty( void )
{
    if( -1==top )
    {
        printf("charstack is empty/n");
        return 1;
    }
    else
    {
        return 0;
    }
}

void charStackPush( char ch )
{
    assert( !charstackIsFull() );
    charstack[++top] = ch;
}

char charStackPop( void )
{
    assert( !charstackIsEmpty() );
    return     charstack[top--];
}

int intstackIsFull( void )
{
    if( int_top==(INTSTACKSIZE-1) )
    {
        printf("intstack is full/n");
        return 1;
    }
    else
    {
        return 0;
    }
}

int intstackIsEmpty( void )
{
    if( int_top==(-1) )
    {
        printf("intstack is empty/n");
        return 1;
    }
    else
    {
        return 0;
    }
}

void intStackPush( int data )
{
    assert( !intstackIsFull() );
    intstack[++int_top] = data;
}

int intStackPop( void )
{
    assert( !intstackIsEmpty() );
    return     intstack[int_top--];
}


int charIsDigit( char ch )
{
    if( ch>='0'&&ch<='9' )
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int isp( char ch )
{
    int pri;
    switch(ch)
    {
    case '#':
        pri = 0;
        break;
    case '(':
        pri = 1;
        break;
    case '^':
        pri = 7;
        break;
    case '*':
    case '/':
    case '%':
        pri = 5;
        break;
    case '+':
    case '-':
        pri = 3;
        break;
    case ')':
        pri = 8;
        break;
    default:
        assert(0);
    }
    return pri;
}

int icp( char ch )
{
    int pri;
    switch(ch)
    {
    case '#':
        pri = 0;
        break;
    case '(':
        pri = 8;
        break;
    case '^':
        pri = 6;
        break;
    case '*':
    case '/':
    case '%':
        pri = 4;
        break;
    case '+':
    case '-':
        pri = 2;
        break;
    case ')':
        pri = 1;
        break;
    default:
        assert(0);
    }
    return pri;
}



int main( void )
{
    char infix[256] = "12+8*(18-18)*3-88/4#";
    char *pInfix = NULL;
    int temp;
    int flag;
    char ch,y;

    int left;
    int right;

    struct element *head = NULL;
    struct element *p1 = NULL;
    struct element *p2 = NULL;


    printf("Gdq Test!!!/n");

    pInfix = infix;

    p1 = p2 = (struct element *)malloc(sizeof(struct element));

    ch = *pInfix;

    charStackPush('#');

    while(ch!='#')
    {
        temp = 0;
        flag = 0;

        while( charIsDigit(ch) )
        {
            temp *= 10;
            temp += *pInfix-'0';
            pInfix++;
            ch = *pInfix;
            flag = 1;
        }

        if( 1==flag )
        {
            p1->data = temp;
            p1->ch   = '!';
            if( NULL==head )
            {
                head = p1;
            }
            else
            {
                p2->next = p1;
            }

            p2 = p1;

            p1 = (struct element *)malloc(sizeof(struct element));
        }
        else if( ')'==ch )
        {
            for( y = charStackPop() ; y!='(' ; y = charStackPop() )
            {
                p1->data = 0;
                p1->ch   = y;
                if( NULL==head )
                {
                    head = p1;
                }
                else
                {
                    p2->next = p1;
                }

                p2 = p1;

                p1 = (struct element *)malloc(sizeof(struct element));
            }   
            pInfix++;
            ch = *pInfix;
        }
        else
        {
            for( y = charStackPop() ; isp(y)>icp(ch) ; y = charStackPop() )
            {
                p1->data = 0;
                p1->ch   = y;
                if( NULL==head )
                {
                    head = p1;
                }
                else
                {
                    p2->next = p1;
                }

                p2 = p1;

                p1 = (struct element *)malloc(sizeof(struct element));
            }
            charStackPush(y);
            charStackPush(ch);   
            pInfix++;
            ch = *pInfix;
        }
    }

    while(!charstackIsEmpty())
    {
        y = charStackPop();
        p1->data = 0;
        p1->ch   = y;
        if( NULL==head )
        {
            head = p1;
        }
        else
        {
            p2->next = p1;
        }

        p2 = p1;

        p1 = (struct element *)malloc(sizeof(struct element));
    }

    p2->next = NULL;

    for( p1 = head ; p1->next!=NULL ; p1 = p1->next )
    {
        printf("%d %c/n",p1->data,p1->ch);
    }

    for( p1 = head ; p1->next!=NULL ; p1 = p1->next )
    {
        switch( p1->ch )
        {
        case '+':
            right = intStackPop();
            left  = intStackPop();
            temp  = left+right;
            intStackPush(temp);
            break;
        case '-':
            right = intStackPop();
            left  = intStackPop();
            temp  = left-right;
            intStackPush(temp);
            break;
        case '*':
            right = intStackPop();
            left  = intStackPop();
            temp  = left*right;
            intStackPush(temp);
            break;
        case '/':
            right = intStackPop();
            left  = intStackPop();
            temp  = left/right;
            intStackPush(temp);
            break;
        case '!':
            intStackPush(p1->data);
            break;
        default:
            assert(0);
        }
    }

    printf("/n%d/n",intStackPop());

    return 0;
}