棧可以是順序棧，也可以是鏈棧。

順序棧：

 1 const int maxSize = 100;
 2 // 順序棧
 3 struct SqStack{
 4     int data[maxSize];
 5     int top;
 6 }
 7 
 8 void initStack(SqStack &s)
 9 {
10     s.top=-1;
11 }
12 
13 int isEmpty(SqStack s)
14 {
15     if(s.top == -1)
16         return 1;
17     else
18         return 0;
19 }
 
20 
21 int push(SqStack &s,int x)
22 {
23     if(s.top == maxSize-1)
24         return 0;
25     ++(s.top);
26     s.data[s.top]=x;
27     return 1
28 }
29 
30 int pop(SqStack &s,int &x)
31 {
32     if(s.top==-1)
33         return 0;
34     x = s.data[s.top];
35     --(s.top);
36     return 1
 
;
37 }

順序棧還可以更簡化，使用數組來創建：

1 //簡化版順序棧
2 int stack[maxSize];   
3 int top = -1;             //  初始化棧
4 stack[++top] = x;   //  進棧
5 x = stack[top--];     //  出棧

鏈棧：

 1 // 鏈棧
 2 struct LNode{
 3     int data;
 4     LNode *next;
 5 }
 6 
 7 void InitStack(LNode *&lst)
 8 {
 9     lst = new LNode;
10     lst->next = NULL;
 
11 }
12 
13 int isEmpty(LNode *lst)
14 {
15     if(lst->next == NULL)
16         return 1;
17     else
18         return 0;
19 }
20 
21 void push(LNode *lst,int x)
22 {
23     LNode *p;
24     p = new LNode;
25 
26     p->data = x;
27     p->next = lst->next;
28     lst->next = p;
29 }
30 
31 int pop(LNode *lst,int &x)
32 {
33     LNode *p;
34     if(lst->next == NULL)
35         return 0;
36     p = lst->next;
37     x = p->data;
38     lst->next = p->next;
39     free(p);
40     return 1;
41 }

棧的應用：

1. 編寫算法，判斷一個算術表達式中的括號是否配對。表達式已經存入字符數組中，元素從下標1開始存儲，表達式中的字符個數為n

思路：遍歷這個表達式，當遇到第一個 ‘(‘ 時，入棧，繼續遍歷，如果遇到 ‘)‘ ，則將 ‘(‘ 出棧，劃掉這兩個括號，繼續處理下一組括號。如果前面所有括號都被劃掉，而下一個括號卻是 ‘)‘ ，

則括號不匹配，因為前面已經沒有與之匹配的 ‘(‘ 了。如果下一個括號還是 ‘(‘ ，則先處理這個括號，處理完再處理前面的 ‘(‘ 。

 1 int match(char exp[],int n)
 2 {
 3     char stack[maxSize];
 4     int top = -1;
 5  
 6     int i;
 7     for(i=1;i<=n;++i){
 8         if(exp[i]==‘(‘)
 9             stack[++top]=‘(‘;
10         if(exp[i]==‘)‘){
11             if(top==-1)
12                 return 0;
13             else
14                 --top;
15         }
16     }
17     if(top==-1)   // 所有括號都被處理掉了，返回1
18         return 1;   
19     else              // 否則返回0
20         return 0;
21 }

2.編寫一個函數，求後綴表達式的值。（即逆波蘭表達式的值） 表達式被存於一個字符數組中，以‘\0‘結尾，並假設後綴表達式中的數字都只有一位。

先定義一個運算函數：

 1 int op(int a,char op, int b)
 2 {
 3     if(op==‘+‘) return a+b;
 4     if(op==‘‘-) return a-b;
 5     if(op==‘‘*) return a*b;
 6     if(op==‘/‘){
 7         if(b==0){
 8             cout<<"Error"<<endl;
 9             return 0;
10         }else
11             return a/b;
12     }
13 }

後綴表達式計算函數：

 1 int com(char exp[])
 2 {
 3     int a,b,c;   //   a、b為操作數，c存儲計算結果
 4     int stack[maxSize];
 5     int top = -1;
 6 
 7     char op;
 8     for(i=0;exp[i]!=‘\0‘;i++){
 9         if(exp[i]>=‘0‘&&exp[i]<=‘9‘)
10             stack[++top]=exp[i]-‘0‘;
11         else{
12             op = exp[i];
13             a=stack[top--];
14             b=stack[top--];
15       //  註意，根據後綴表達式的計算方式，應該用後出棧的數op先出棧的數
16             c=op(b,op,a);   
17             stack[++top]=c;
18         }   
19     }
20     return stack[top];
21 }

棧操作及其應用