C語言（列印函式採用的c++）：

棧的連結串列實現—— 棧的初始化（建立||清空）、入棧、出棧（獲取棧頂元素）
棧的陣列實現——初始化、入棧、出棧、清空棧

參考資料：《資料結構與演算法分析——C語言描述》 P46

一. 棧的連結串列實現

StackLinkList.cpp

1. /* 
2. 功能：棧的連結串列實現: 棧的初始化（建立||清空）、入棧、出棧（獲取棧頂元素） 
3. Date: 2015/01/23 
4. Author : quinn 
5. */
6. #include <iostream>
7. #include <stdlib.h>
8. usingnamespace std;  
9. typedef
   int Item;  
10. typedefstruct Node Node;  
11. typedef Node* Stack;  
12. struct Node  
13. {  
14.     Item item;  
15.     Node* next;  
16. };  
17. void StackPop(Stack s);  
18. Stack StackInit(Stack s) //建立或清空（初始化）
19. {  
20.     if (s == NULL) //建立
21.     {  
22.         s = (Stack)malloc(sizeof(*s));  
23.         s->next = NULL;  
24.     }  
25.     else
    //清空
26.         while(s->next != NULL)  
27.             StackPop(s);  
28.     cout << "初始化成功！" <<endl;  
29.     return s;  
30. }  
31. void StackPush(Stack s, Item item) //入棧
32. {  
33.     Node* tmpNode = (Node*)malloc(sizeof(*tmpNode));  
34.     tmpNode->item = item;  
35.     tmpNode->next = s->next;  
36.     s->next = tmpNode;  
37.     cout << "PUSH: " << item <<endl;  
38. }  
39. Item StackPopAndTop(Stack s) //出棧並返回棧頂元素值
40. {  
41.     if (s->next == NULL)  
42.     {  
43.         cout << "空棧，POPAndTop失敗" <<endl;  
44.         return -1; //返回-1作警告
45.     }  
46.     else
47.     {  
48.         Node* firstNode = s->next;  
49.         s->next = s->next->next;  
50.         return firstNode->item;  
51.     }  
52. }  
53. void StackPop(Stack s) //出棧
54. {  
55.     if (s->next == NULL)  
56.     {  
57.         cout << "空棧，POP失敗" <<endl;  
58.     }  
59.     else
60.     {  
61.         Node* firstNode = s->next;  
62.         s->next = s->next->next;  
63.         free(firstNode);  
64.     }  
65. }  
66. Item StackTop(Stack s) //僅獲取棧頂元素
67. {  
68.     if (s->next == NULL)  
69.     {  
70.         cout << "空棧，獲取棧頂元素失敗" <<endl;  
71.     }  
72.     return (s->next)->item;  
73. }  
74. int main()  
75. {  
76.     Stack s = NULL;  
77.     s = StackInit(s);  
78.     for(int i = 0; i < 10; i++)  
79.         StackPush(s, i);  
80.     for(int i = 0; i < 5; i++)  
81.         cout << StackPopAndTop(s) <<endl;  
82.     StackInit(s);  
83.     cout << StackPopAndTop(s) <<endl;  
84.     system("pause");  
85.     return 0;  
86. }  

二. 棧的陣列實現

1. /* 
2. 功能：棧的陣列實現——初始化、入棧、出棧、清空棧 
3. 注： 定義棧為空時，棧頂index為 -1；棧滿時，棧頂index為棧的長度-1 
4. Date：2015/01/23 
5. Author ： quinn 
6. */
7. #include <iostream>
8. #include "item.h"
9. #define STACK_SIZE 10 //認為設定棧的長度為10
10. #define FULL_STACK (STACK_SIZE - 1)
11. #define EMPTY_STACK (-1)
12. usingnamespace std;  
13. typedefstruct stack stack;  
14. typedefint Item;  
15. struct stack  
16. {  
17.     Item *stackItem;  
18.     int stackTop;  
19. };  
20. void Error(constchar* str) //異常時輸出提示
21. {  
22.     cout << "Error: " << str << endl;  
23. }  
24. int IsFull(stack* s) //判斷是否棧滿
25. {  
26.     if (s->stackTop == FULL_STACK)  
27.         return 1;  
28.     else
29.         return 0;  
30. }  
31. int IsEmpty(stack* s) //判斷是否空棧
32. {  
33.     if (s->stackTop == EMPTY_STACK)  
34.         return 1;  
35.     else
36.         return 0;  
37. }  
38. stack* StackInit( stack* s, int maxN) //初始化棧空間
39. {  
40.      s->stackTop = -1; //空棧初始化 Top = -1
41.      s->stackItem = (Item*)malloc(maxN * sizeof(Item)); //分配棧空間
42.      return s;  
43. }  
44. void StackMakeEmpty(stack* s) //清空棧
45. {  
46.     if (!IsEmpty(s))  
47.         s->stackTop = EMPTY_STACK;  
48. }  
49. void StackPush(stack* s, Item item) //入棧
50. {  
51.     if (!IsFull(s))  
52.     {  
53.         s->stackItem[++(s->stackTop)] = item;  
54.         cout << "PUSH: " << item <<endl;  
55.     }  
56.     else
57.         Error("棧已滿，push失敗");  
58. }  
59. Item StackPop(stack *s) //出棧
60. {  
61.     if (!IsEmpty(s))  
62.     {  
63.         return s->stackItem[(s->stackTop)--];  
64.     }  
65.     else
66.         Error("空棧，pop失敗");  
67. }  
68. int main()  
69. {  
70.     stack *s = (stack*)malloc(sizeof(*s));  
71.     StackInit(s, STACK_SIZE);  
72.     for (int i = 0; i < 11; i++)  
73.     {  
74.         StackPush(s, i);  
75.     }  
76.     cout << "POP: " << StackPop(s) << endl;  
77.     cout << "POP: " << StackPop(s) << endl;  
78.     StackPush(s, 20);  
79.     cout << "POP: " << StackPop(s) << endl;  
80.     StackMakeEmpty(s);  
81.     StackPop(s);  
82.     StackPush(s, 30);  
83.     cout << "POP: " << StackPop(s) << endl;  
84.