数据结构之链式栈的应用-简单表达式计算

#ifndef _HEAD_H_
#define _HEAD_H_

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

typedef int DataType;
//结点类型
struct node
{
    DataType data;
    struct node *next;
};

//栈头类型
typedef struct 
{
    //记录栈顶结点首地址
    struct node *top;
    //记录栈中元素个数
    int n;
}LinkStack;

extern LinkStack *create_empty_linkstack();
extern int is_empty_linkstack(LinkStack *s);
extern int push_linkstack(LinkStack *s,DataType data);
extern DataType pop_linkstack(LinkStack *s);
extern DataType get_top_data(LinkStack *s);

#endif

#include "head.h"


LinkStack *create_empty_linkstack()
{
    LinkStack *s = NULL;


    s = (LinkStack *)malloc(sizeof(LinkStack));
    s->top = NULL;
    s->n = 0;


    return s;
}


int is_empty_linkstack(LinkStack *s)
{
    return s->top == NULL;
}


int push_linkstack(LinkStack *s,DataType data)
{
    struct node *temp = NULL;


    temp = (struct node *)malloc(sizeof(struct node));
    temp->data = data;


    //链表结点的连接
    temp->next = s->top;


    //更新栈顶指针
    s->top = temp;
    
    s->n++;


    return 0;
}


DataType pop_linkstack(LinkStack *s)
{
    struct node *temp = NULL;
    DataType data;


    temp = s->top;
    data = temp->data;


    s->top = s->top->next;
    s->n--;


    free(temp);


    return data;
}


DataType get_top_data(LinkStack *s)
{
    return s->top->data;
}
#if 0
int main()
{
    LinkStack *s = NULL;
    int i = 0;


    s = create_empty_linkstack();


    for(i = 0;i < 9;i++)
    {
        push_linkstack(s,i);
    }


    printf("top : %d\n",get_top_data(s));


    while(!is_empty_linkstack(s))
    {
        printf("%d ",pop_linkstack(s));
    }
    putchar('\n');


    return 0;
}
#endif

#include "head.h"


#define N 100


int get_priority(char c)
{
    switch(c)
    {
    case '(':
        return 0;
    case '+':
    case '-':
        return 1;
    case '*':
    case '/':
    case '%':
        return 2;
    }


    return -1;
}


void compute(LinkStack *operand,LinkStack *operator)
{
    int data,data1,data2; 


    data2 = pop_linkstack(operand);
    data1 = pop_linkstack(operand);


    switch(pop_linkstack(operator))
    {
    case '+':
        data = data1 + data2;
        break;
    case '-':
        data = data1 - data2;
        break;
    case '*':
        data = data1 * data2;
        break;
    case '/':
        data = data1 / data2;
        break;
    case '%':
        data = data1 % data2;
        break;
    }


    push_linkstack(operand,data);
}


void deal_with(LinkStack *operand,LinkStack *operator,char c)
{
    int cur_level = -1;


    cur_level = get_priority(c);
    //top_level = get_priority(get_top_data(operator));


    while(!(is_empty_linkstack(operator) || cur_level > get_priority(get_top_data(operator))))
    {
        compute(operand,operator);
    }


    push_linkstack(operator,c);


#if 0/*{{{*/
    if(is_empty_linkstack(operator) || cur_level > top_level)
    {
        push_linkstack(operator,c);
    }
    else
    {
        compute();
        goto
    }
#endif/*}}}*/
}


int main()
{
    char buf[N] = {0};
    LinkStack *operand = NULL;//运算数栈
    LinkStack *operator = NULL;//运算符栈
    char *p = buf;
    int data = 0;
    


    printf("Input expression:");
    scanf("%99[^\n]",buf);


    puts(buf);


    operand = create_empty_linkstack();
    operator = create_empty_linkstack();


    while(*p != '\0')
    {
        if(*p == ' ')
        {
            p++;
            continue;
        }


        if(*p >= '0' && *p <= '9')
        { 
            data = 0;
            while(*p >= '0' && *p <= '9')
            {
                data = data * 10 + *p - '0';
                p++;
            }
            //printf("data = %d\n",data);


            push_linkstack(operand,data);
            continue;
        }


        if(*p == '+' || *p == '-' || *p == '*' ||
            *p == '/' || *p == '%')
        {
            deal_with(operand,operator,*p); 
            p++;
            continue;
        }


        if(*p == '(')
        {
            push_linkstack(operator,*p);
            p++;
            continue;
        }


        if(*p == ')')
        {
            while(!is_empty_linkstack(operator) && get_top_data(operator) != '(')
            {
                compute(operand,operator);
            }


            if(is_empty_linkstack(operator))
            {
                printf("( lost.\n");
                return -2;
            }


            pop_linkstack(operator);


            p++;
            continue;
        }


        printf("%c is invalid char.\n",*p);
        return -1;
    }


    while(!is_empty_linkstack(operator))
    {
        compute(operand,operator);
    }


    printf("%s = %d\n",buf,pop_linkstack(operand));


    return 0;
}