2.3 后进先出结构：栈

 1 typedef struct stack
 2 {
 3     DATA data[SIZE+1]; //数据元素 
 4     int top; //栈顶 
 5 }SeqStack;
 6 SeqStack *SeqStackInit()
 7 {
 8     SeqStack *p;
 9     if(p=(SeqStack *)malloc(sizeof(SeqStack))) //申请栈内存 
10     {
11         p->top=0; //设置栈顶为0 
12         return p;//返回指向栈的指针 
13     }
14     return NULL;
15 }
16 int SeqStackIsEmpty(SeqStack *s) //判断栈是否为空 
17 {
18     return(s->top==0);
19 }
20 void SeqStackFree(SeqStack *s) //释放栈所占用空间 
21 {
22     if(s)
23         free(s);
24 }
25 void SeqStackClear(SeqStack *s)  //清空栈 
26 {
27     s->top=0;
28 } 
29 int SeqStackIsFull(SeqStack *s) //判断栈是否已满
30 {
31     return(s->top==SIZE);
32 } 
33 int SeqStackPush(SeqStack *s,DATA data) //入栈操作 
34 {
35      if((s->top+1)>SIZE)
36      {
37          printf("栈溢出!\n"); 
38          return 0;
39      }
40      s->data[++s->top]=data;//将元素入栈
41      return 1; 
42 }
43 DATA SeqStackPop(SeqStack *s) //出栈操作 
44 {
45      if(s->top==0)
46      {
47          printf("栈为空！");
48          exit(0);
49      }
50      return (s->data[s->top--]);
51 }
52 DATA SeqStackPeek(SeqStack *s) //读栈顶数据
53 {
54      if(s->top==0)
55      {
56          printf("栈为空！");
57          exit(0);
58      }
59      return (s->data[s->top]);
60 } 

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #define SIZE 50
 4 typedef struct
 5 {
 6     char name[15];
 7     int age;
 8 }DATA;
 9 #include "2-11 SeqStack.h"
10 int main()
11 {
12     SeqStack *stack;
13     DATA data,data1;    
14     stack=SeqStackInit();  //初始化栈
15     printf("入栈操作：\n");
16     printf("输入姓名 年龄进行入栈操作:"); 
17     scanf("%s%d",data.name,&data.age);
18     SeqStackPush(stack,data);
19     printf("输入姓名 年龄进行入栈操作:"); 
20     scanf("%s%d",data.name,&data.age);
21     SeqStackPush(stack,data);
22     printf("\n出栈操作：\n按任意键进行出栈操作:");
23     getch();
24     
25     data1=SeqStackPop(stack);
26     printf("出栈的数据是(%s,%d)\n" ,data1.name,data1.age);        
27     printf("再按任意键进行出栈操作:");
28     getch();
29     
30     data1=SeqStackPop(stack);
31     printf("出栈的数据是(%s,%d)\n" ,data1.name,data1.age); 
32     SeqStackFree(stack); //释放栈所占用的空间 
33     getch();
34     return 0;
35 }

  1 #include<stdio.h> 
  2 #include<stdlib.h>
  3 #define SIZE 50
  4 typedef int DATA;
  5 #include "2-11 SeqStack.h"
  6 int IsOperator(char c) //检查字符是否为运算符 
  7 {
  8     switch(c)
  9     {
 10         case‘+‘:
 11         case‘-‘:
 12         case‘*‘:
 13         case‘/‘:
 14         case‘(‘:
 15         case‘)‘:
 16         case‘=‘:
 17             return 1;
 18             break;
 19         default:
 20             return 0;
 21             break;
 22     } 
 23 } 
 24 int PRI(char oper1,char oper2) //判断两个运算符的优先级
 25 // oper1>oper2返回1 
 26 //oper1<oper2返回-1
 27 //oper1=oper2返回0 
 28 {
 29     int pri;
 30     switch(oper2) //判断运算符优先级 
 31     {
 32         case ‘+‘:
 33         case ‘-‘:
 34             if(oper1==‘(‘||oper1==‘=‘) //为左括号或表达式开始符号 
 35                 pri=-1; //返回小于 
 36             else 
 37                 pri=1;
 38             break;
 39         case ‘*‘:
 40         case ‘/‘:
 41             if(oper1==‘*‘||oper1==‘/‘||oper1==‘)‘)
 42                 pri=1;
 43             else
 44                 pri=-1;
 45             break;
 46         case ‘(‘:
 47             if(oper1==‘)‘) //右括号右侧不能马上出现左括号 
 48             {
 49                 printf("语法错误!\n");
 50                 exit(0);
 51             }else
 52                 pri=-1;
 53             break;
 54         case‘)‘:
 55             if(oper1==‘(‘)
 56                 pri=0;
 57             else if (oper1==‘=‘)
 58             {
 59                 printf("括号不匹配!\n");
 60                 exit(0);
 61             }else
 62                 pri=1;
 63             break;
 64         case ‘=‘ :
 65             if(oper1==‘(‘)
 66             {
 67                 printf("括号不匹配!\n");
 68                 exit(0);
 69             }else if(oper1==‘=‘)
 70                 pri=0;
 71             else
 72                 pri=1;
 73             break;
 74     }
 75     return pri; 
 76 }
 77 int Calc(int a,int oper,int b) //计算两个操作数的结果 
 78 {
 79     switch(oper)
 80     {
 81         case‘+‘:return a+b;
 82         case‘-‘:return a-b;
 83         case‘*‘:return a*b;
 84         case‘/‘:
 85             if(b!=0)
 86                return a/b;
 87             else
 88             {
 89                 printf("除0溢出!\n");
 90                 exit(0); 
 91             }  
 92     }
 93 } 
 94 int CalcExp(char exp[]) //表达式计算函数 
 95 {
 96     SeqStack *StackOper,*StackData;
 97     int i=0,flag=0;
 98     DATA a,b,c,q,x,t,oper;
 99     
100     StackOper=SeqStackInit(); //初始化两个栈 
101     StackData=SeqStackInit();
102 
103     q=0;
104     x=‘=‘;
105     SeqStackPush(StackOper,x); //首先将等号(=)进入操作符栈 
106     x=SeqStackPeek(StackOper); //获取操作符栈的首元素  
107     c=exp[i++];
108     while(c!=‘=‘ || x!=‘=‘)
109     {
110         if(IsOperator(c)) //若输入的是运算符 
111         {
112             if(flag){
113                 SeqStackPush(StackData,q);//将操作数入栈 
114                 q=0;
115                 flag=0;
116             }
117             switch(PRI(x,c)) //判断运算符的优先级 
118             {
119                 case -1:
120                     SeqStackPush(StackOper,c);//运算符进栈 
121                     c=exp[i++];
122                     break;
123                 case 0:
124                     c=SeqStackPop(StackOper); //运算符出栈 (抛弃)
125                     c=exp[i++];
126                     break;
127                 case 1:
128                     oper=SeqStackPop(StackOper); //运算符出栈 
129                     b=SeqStackPop(StackData);//两个操作数出栈 
130                     a=SeqStackPop(StackData);
131                     t=Calc(a,oper,b);
132                     SeqStackPush(StackData,t);//将运算结果入栈 
133                     break;
134             }
135         }else if(c>=‘0‘&&c<=‘9‘) //若输入字符在0~9之间 
136         {
137             c-=‘0‘;
138             q=q*10+c;
139             c=exp[i++];
140             flag=1;
141         }
142         else
143         {
144             printf("输入错误!\n");
145             getch();
146             exit(0);
147         }
148         x=SeqStackPeek(StackOper);//获取栈顶的运算符 
149     }
150     q=SeqStackPop(StackData);
151     SeqStackFree(StackOper);     //释放栈所占用的空间 
152     SeqStackFree(StackData);
153     return q; //出栈，返回结果 
154 } 
155 
156 int main() 
157 {
158     int c;
159     char exp[80];
160     printf("请输入要计算的表达式(以=结束):"); 
161     scanf("%s",exp);
162     printf("%s%d\n",exp,CalcExp(exp));
163     getch();
164     return 0;
165 }