1. #include<stdio.h> 
    2.  
         
  2. #include<string.h> 
    3.  
         
  3. #include<ctype.h> 
    4.  
         
  4. #include<stdlib.h> 
    5.  
         
  5. #define MAXSIZE 30 
    6.  
         
  6.   
    7.  
         
  7. typedef int ElemType; 
    8.  
         
  8. typedef struct Stack{ 
          //栈结构  
    9.  
         
  9.     ElemType data[MAXSIZE]; 
    10.  
         
  10.     int top;//栈顶指针  
    11.  
         
  11. }Stack,*pStack; 
    12.  
         
  12.   
    13.  
         
  13. void initStack(pStack S){ 
          //初始化栈  
    14.  
         
  14.     S->top = -1; 
    15.  
         
  15. } 
    16.  
         
  16. bool push(pStack S,ElemType e){  
    17.  
         
  17.     if(S->top == MAXSIZE-1){ 
    18.  
         
  18.         puts("栈满"); 
    19.  
         
  19.         return false; 
    20.  
         
  20.     } 
    21.  
         
  21.     S->data[++(S->top)] = e; 
    22.  
         
  22.     return true; 
    23.  
         
  23. } 
    24.  
         
  24. bool pop(pStack S,ElemType *e){ 
    25.  
         
  25.     if(S->top == -1){ 
    26.  
         
  26.         puts("栈空"); 
    27.  
         
  27.         return false; 
    28.  
         
  28.     } 
    29.  
         
  29.     *e = S->data[(S->top)--]; 
    30.  
         
  30.     return true; 
    31.  
         
  31. } 
    32.  
         
  32. int main(void){ 
    33.  
         
  33.     char string[MAXSIZE];//存储字符串  
    34.  
         
  34.     char tempNumber[MAXSIZE];//存储数值字符  
    35.  
         
  35.     char ch;//分解每个字符  
    36.  
         
  36.     int index; 
    37.  
         
  37.     int number;//从字符中获得的数值  
    38.  
         
  38.     int result = 0;//最终结果  
    39.  
         
  39.     int count = 0;//数字计数  
    40.  
         
  40.     int a1,a2;//辅助数值计算  
    41.  
         
  41.     bool tag;//标志位，数字是否已经结束  
    42.  
         
  42.     Stack numberStack;//数字栈  
    43.  
         
  43.     pStack S = &numberStack;//指向栈的指针  
    44.  
         
  44.      
    45.  
         
  45.     initStack(S);//初始化栈  
    46.  
         
  46.     puts("Enter a string"); 
    47.  
         
  47.     gets(string); 
    48.  
         
  48.     for(index=0;index<strlen(string);index++){ 
    49.  
         
  49.         ch = string[index]; 
    50.  
         
  50.         if(isdigit(ch)){ 
    51.  
         
  51.             tag = true;//现在输入的是数字  
    52.  
         
  52.             tempNumber[count] = ch; 
    53.  
         
  53.             count++; 
    54.  
         
  54.         } 
    55.  
         
  55.         else{ 
    56.  
         
  56.             if(tag){ 
          //判断上一个字符是不是数值  
    57.  
         
  57.                 tempNumber[count] = '\0';//一个数值结束了  
    58.  
         
  58.                 number = atoi(tempNumber); 
    59.  
         
  59.                 push(S,number); 
    60.  
         
  60.                 count = 0;//重新计算数值  
    61.  
         
  61.                 tag = false; 
    62.  
         
  62.             } 
    63.  
         
  63.             switch(ch){ 
    64.  
         
  64.                 case '+': 
    65.  
         
  65.                      pop(S,&a2); 
    66.  
         
  66.                      pop(S,&a1); 
    67.  
         
  67.                      push(S,a1+a2); 
    68.  
         
  68.                      break; 
    69.  
         
  69.                 case '-': 
    70.  
         
  70.                      pop(S,&a2); 
    71.  
         
  71.                      pop(S,&a1); 
    72.  
         
  72.                      push(S,a1-a2); 
    73.  
         
  73.                      break; 
    74.  
         
  74.                 case '*': 
    75.  
         
  75.                      pop(S,&a2); 
    76.  
         
  76.                      pop(S,&a1); 
    77.  
         
  77.                      push(S,a1*a2); 
    78.  
         
  78.                      break; 
    79.  
         
  79.                 case '/': 
    80.  
         
  80.                      pop(S,&a2); 
    81.  
         
  81.                      pop(S,&a1); 
    82.  
         
  82.                      push(S,a1/a2); 
    83.  
         
  83.                      break; 
    84.  
         
  84.                 default: 
    85.  
         
  85.                      break; 
    86.  
         
  86.             } 
    87.  
         
  87.         } 
    88.  
         
  88.     } 
    89.  
         
  89.     pop(S,&result); 
    90.  
         
  90.     printf("%d",result); 
    91.  
         
  91.     getchar(); 
    92.  
         
  92.     return 0; 
    93.  
         
  93. } 
    94.