C语言中栈和队列实现表达式求值的实例

#include<stdio.h> 
#include<stdlib.h> 
 
#define OK 1 
#define ERROR 0 
#define STACK_SIZE 20 
#define STACK_INCREMENT 10 
#define QUEUE_SIZE 20 
 
typedef int Status; 
 
typedef char StackElemtype; 
typedef struct Stack 
  StackElemtype* base; 
  StackElemtype* top; 
  int stackSize; 
Stack; 
Status StackInit(Stack* s) 
  s->base = (StackElemtype*)malloc(sizeof(StackElemtype) * STACK_SIZE); 
  if( !s->base ) 
    return ERROR; 
  s->top = s->base; 
  s->stackSize = STACK_SIZE; 
  return OK; 
 
Status Pop(Stack* s,StackElemtype* value) 
  if( s->base == s->top ) 
    printf("\nstack empty\n"); 
    return ERROR; 
   
  *value = *(--(s->top)); 
  return OK; 
 
Status Push(Stack* s,StackElemtype value) 
  if( s->top - s->base == s->stackSize) 
     
    s->base = (StackElemtype*)realloc(s->base,sizeof(StackElemtype) * (STACK_INCREMENT + STACK_SIZE)); 
    if( !s->base ) 
      return ERROR; 
    s->top = s->base + STACK_SIZE; 
    s->stackSize = STACK_SIZE + STACK_INCREMENT; 
   
  *(s->top) = value; 
  s->top++; 
  return OK; 
 
int StackLength(Stack s) 
  return s.top - s.base; 
 
 
typedef double StackElemtype_ForValueExperssion; 
typedef struct Stack_2 
  StackElemtype_ForValueExperssion* base; 
  StackElemtype_ForValueExperssion* top; 
  int stackSize; 
Stack_2; 
Status StackInit_2(Stack_2* s) 
  s->base = (StackElemtype_ForValueExperssion*)malloc(sizeof(StackElemtype_ForValueExperssion) * STACK_SIZE); 
  if( !s->base ) 
    return ERROR; 
  s->top = s->base; 
  s->stackSize = STACK_SIZE; 
  return OK; 
 
Status Pop_2(Stack_2* s,StackElemtype_ForValueExperssion* value) 
  if( s->base == s->top ) 
    printf("\nstack empty\n"); 
    return ERROR; 
   
  *value = *(--(s->top)); 
  return OK; 
 
Status Push_2(Stack_2* s,StackElemtype_ForValueExperssion value) 
  if( s->top - s->base == s->stackSize) 
    s->base = (StackElemtype_ForValueExperssion*)realloc(s->base,sizeof(StackElemtype_ForValueExperssion) * (STACK_INCREMENT + STACK_SIZE)); 
    if( !s->base ) 
      return ERROR; 
    s->top = s->base + STACK_SIZE; 
    s->stackSize = STACK_SIZE + STACK_INCREMENT; 
   
  *(s->top) = value; 
  s->top++; 
  return OK; 
 
 
typedef double QueueElemtype; 
typedef char  QueueOperatorValue; 
typedef struct QueueNode 
  QueueElemtype data; 
  QueueOperatorValue operator; 
  struct QueueNode* next; 
  int flag; 
QueueNode,*QueueNodePtr; 
typedef struct Queue 
  QueueNodePtr front; 
  QueueNodePtr rear; 
Queue; 
 
Status QueueInit(Queue* q) 
  q->front = (QueueNodePtr)malloc(sizeof(QueueNode)); 
  if( !q->front ) 
    return ERROR; 
  q->rear = q->front; 
  q->rear->next = NULL; 
  return OK; 
 
Status QueueInsert(Queue* q,QueueElemtype value) 
  QueueNodePtr new; 
  new = (QueueNodePtr)malloc(sizeof(QueueNode)); 
  if( !new ) 
    return ERROR; 
  new->data = value; 
  new->flag = 1; 
  new->next = NULL; 
  q->rear->next = new; 
  q->rear = new; 
  return OK; 
 
Status QueueInsert_operatorValue(Queue* q,QueueOperatorValue value) 
  QueueNodePtr new; 
  new = (QueueNodePtr)malloc(sizeof(QueueNode)); 
  if( !new ) 
    return ERROR; 
  new->operator = value; 
  new->flag = 0; 
  new->next = NULL; 
  q->rear->next = new; 
  q->rear = new; 
  return OK; 
 
Status QueueDelete(Queue* q,QueueElemtype* value,QueueOperatorValue *operator,int* symbol) 
  QueueNodePtr first; 
  if( q->front == q->rear ) 
    return ERROR; 
  first = q->front->next; 
  if( first->flag == 1 ) 
    *value = first->data; 
    *symbol = 1; 
   
  else 
    *operator = first->operator; 
    *symbol = 0; 
   
  q->front->next = first->next; 
  if( first == q->rear ) 
    q->rear = q->front; 
   
  return OK; 
 
 
/* 利用栈将中缀表达式转化为后缀表达式： 
 * —————————————————————————————————————————————————————————————— 
 * | 用户的输入  |      进行的处理      | 
 * |  0~9：   | 直接输出到控制台        | 
 * |  /，*，(  | 直接Push          | 
 * |  +，-    | 将栈中的元素Pop直到1.栈空或者是2.遇到(   | 
 * |  )     | 在遇到(之前将栈中的元素全部Pop   | 
 * —————————————————————————————————————————————————————————————— 
 * */ 
 
Status Infix2Postfix(Queue* q) 
  //Queue q; 
  //QueueInit(&q); 
  Stack s; 
  StackInit(&s); 
  char c,e; 
  char bufferDigit10; 
  int i = 0; 
  double longDigit; 
  printf("    Please Enter Infix Expression\n"); 
  printf("------------NOTE: end of '#'--------------\n"); 
  scanf("%c", &c); 
  while( '#' != c) 
    while( c <= '9' && c >= '0' || '.' == c ) 
      bufferDigiti++ = c; 
      bufferDigit = '\0'; 
      scanf("%c", &c); 
      if(!((c <= '9' && c >= '0' ) || '.' == c )) 
        longDigit = atof(bufferDigit); 
        QueueInsert(q,longDigit); 
        i = 0; 
       
     
    if( '(' == c || '*' == c || '/' == c ) 
      Push(&s, c); 
     
    else if( '+' == c || '-' == c ) 
      if( !StackLength(s) ) 
        Push(&s, c); 
      else 
        Pop(&s, &e); 
        while( '(' != e ) 
          QueueInsert_operatorValue(q, e); 
          if( StackLength(s) == 0 ) 
            break; 
          else 
            Pop(&s, &e); 
         
        if( '(' == e ) 
          Push(&s, e); 
        Push(&s, c); 
       
    else if( ')' == c ) 
      Pop(&s, &e); 
      while( '(' != e ) 
        QueueInsert_operatorValue(q, e); 
        Pop(&s, &e); 
       
    else if( '#' == c) 
      break; 
    else 
      printf("input ERROR!\n"); 
      return ERROR; 
     
    scanf("%c", &c); 
   
  while(StackLength(s)) 
    Pop(&s, &e); 
    QueueInsert_operatorValue(q, e); 
   
  QueueInsert_operatorValue(q,'#'); 
  return OK; 
 
Status ShowQueue(Queue q) 
  printf("The Reverse Polish Notation is:"); 
  if(q.front == q.rear) 
    printf("Queue Empty"); 
    return ERROR; 
   
  QueueNodePtr p = q.front->next; 
  while(p != q.rear) 
    if(p->flag) 
      printf("%g ", p->data); 
    else 
      printf("%c ", p->operator); 
    p = p->next;  
   
  printf("\n"); 
  return OK; 
 
 
/* 利用栈求解后缀表达式(逆波兰表达式)的值。 
 * —————————————————————————————————————————————————————————————————————— 
 * |  +，-，*，/，  |   将栈顶的两个元素弹出进行计算，将结果压入栈顶 | 
 * | 数字      |   将其压入栈顶                 | 
 * ——————————————————————————————————————————————————————————————————————— 
 * */ 
Status ValueExpression(Queue q) 
  Stack_2 s; 
  StackInit_2(&s); 
  double o1; 
  double o2; 
  QueueElemtype number; 
  QueueOperatorValue operator; 
  int symbol; 
  QueueDelete(&q,&number,&operator,&symbol); 
  while( symbol == 1 || ( symbol == 0 && '#' != operator)) 
    if(symbol == 1) 
      Push_2(&s, number); 
     
    else if(symbol == 0) 
      switch(operator) 
        case '+': 
          Pop_2(&s,&o1); 
          Pop_2(&s,&o2); 
          Push_2(&s,o2 + o1); 
          break; 
        case '-': 
          Pop_2(&s,&o1); 
          Pop_2(&s,&o2); 
          Push_2(&s,o2 - o1); 
          break; 
        case '*': 
          Pop_2(&s,&o1); 
          Pop_2(&s,&o2); 
          Push_2(&s,o2 * o1); 
          break; 
        case '/': 
          Pop_2(&s,&o1); 
          Pop_2(&s,&o2); 
          Push_2(&s,o2 / o1); 
          break; 
       
     
    QueueDelete(&q,&number,&operator,&symbol); 
   
  Pop_2(&s,&o1); 
  printf("The Value of the Expression is %g\n",o1); 
  return OK; 
 
 
int main() 
  Queue q; 
  QueueInit(&q); 
  Infix2Postfix(&q); 
  ShowQueue(q); 
/* 
  QueueElemtype number; 
  QueueOperatorValue operator; 
  int symbol; 
  QueueDelete(&q,&number,&operator,&symbol); 
  printf("%f,%c,%d\n",number,operator,symbol); 
*/ 
  ValueExpression(q); 
//Stack 
/* 
  Stack s; 
  StackInit(&s); 
  StackElemtype c; 
  Push(&s,'1'); 
  Push(&s,'2'); 
  Push(&s,'3'); 
  Push(&s,'4'); 
  Pop(&s,&c); 
  printf("%c ", c); 
  Pop(&s,&c); 
  printf("%c ", c); 
  Pop(&s,&c); 
  printf("%c ", c); 
  Pop(&s,&c); 
  printf("%c ", c); 
*/ 
  //Queue 
/* 
  Queue q; 
  QueueElemtype c; 
  QueueInit(&q); 
  QueueInsert(&q,1); 
  QueueInsert(&q,2); 
  QueueInsert(&q,3); 
  QueueInsert(&q,4); 
  QueueDelete(&q,&c); 
  printf("%d ", c); 
  QueueDelete(&q,&c); 
  printf("%d ", c); 
  QueueDelete(&q,&c); 
  printf("%d ", c); 
  QueueDelete(&q,&c); 
  printf("%d ", c); 
  if(QueueDelete(&q,&c)) 
    printf("%d ",c); 
   
*/ 
/* 
  Queue q; 
  QueueInit(&q); 
  QueueInsert(&q,2.1); 
  QueueInsert_operatorValue(&q,'+'); 
  QueueInsert(&q,43.1); 
  QueueInsert_operatorValue(&q,'a'); 
  QueueInsert_operatorValue(&q,'('); 
  int iswho; 
  double d; 
  char c; 
  QueueDelete(&q,&d,&c,&iswho); 
  if(iswho == 1) 
    printf("%f ",d); 
  else 
    printf("%c ", c); 
  QueueDelete(&q,&d,&c,&iswho); 
  if(iswho == 1) 
    printf("%f ",d); 
  else 
    printf("%c ", c); 
  QueueDelete(&q,&d,&c,&iswho); 
  if(iswho == 1) 
    printf("%f ",d); 
  else 
    printf("%c ", c); 
  QueueDelete(&q,&d,&c,&iswho); 
  if(iswho == 1) 
    printf("%f ",d); 
  else 
    printf("%c ", c); 
*/ 
  return 0;