栈的本质是一个表，但它限制插入和删除只能在一个位置上进行。这个特殊的位置是表的末端，叫做栈顶(top)。栈的基本操作有Push和Pop两种。这里有两种比较流行的栈的实现方式：一种是用链表实现，另一种是用数组实现。这里，我们先给出链表实现的c源码。
stackList.h头文件定义如下。具体内容可参见《数据结构与算法分析：c语言描述》第三章。
1 #ifndef _STACK_LIST_H
2 #define _STACK_LIST_H
3
4 typedef int ElementType;
5 typedef struct _Node
6 {
7 ElementType Element;
8 struct _Node * Next;
9 }Node;
10 typedef Node * PtrToNode;
11 typedef PtrToNode Stack;
12
13 int IsEmpty( Stack S );
14 Stack CreateStack( void );
15 void DisposeStack( Stack S );
16 void MakeEmpty( Stack S );
17 void Push( Stack S, ElementType X );
18 ElementType Top( Stack S );
19 void Pop( Stack S );
20
21 #endif /* _STACK_LIST_H */
stackList.c
1 /************************************
2 * stack implemention by list
3 * **********************************/
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include "stackList.h"
8
9
10 //判断S是否为空
11 //若为空，返回1，若不为空，返回0
12 int IsEmpty( Stack S )
13 {
14 return S->Next == NULL;
15 }
16
17 //创造一个新栈
18 //返回栈指针
19 Stack CreateStack( void )
20 {
21 Stack S;
22 S = ( Stack )malloc( sizeof( Node ) );
23 if( S == NULL )
24 perror( "Out of space!!!\n");
25 S->Next = NULL;
26 MakeEmpty( S );
27 return S;
28 }
29
30 //清空栈
31 void MakeEmpty( Stack S )
32 {
33 if( S == NULL )
34 perror( "Must use CreateStack first.\n" );
35 else
36 while( !IsEmpty( S ) )
37 Pop( S );
38
39 printf("Make empty \n");
40 }
41
42 //销毁栈
43 void DisposeStack( Stack S )
44 {
45 MakeEmpty( S );
46 free( S );
47 printf("Dispose stack!\n");
48 }
49
50 //压栈操作
51 void Push( Stack S, ElementType X )
52 {
53 PtrToNode newCell;
54 newCell = ( PtrToNode )malloc( sizeof( Node ) );
55 if( newCell == NULL )
56 perror( "Out of space!\n" );
57 else
58 {
59 newCell->Element = X;
60 newCell->Next = S->Next;
61 S->Next = newCell;
62 }
63 }
64
65 //取栈顶元素
66 ElementType Top( Stack S )
67 {
68 if( !IsEmpty( S ) )
69 return S->Next->Element;
70
71 perror( "Stack is empty!\n" );
72 return 0;
73 }
74
75 //弹栈操作
76 void Pop( Stack S )
77 {
78 PtrToNode topCell;
79
80 if( IsEmpty( S ) )
81 perror( "Stack is empty!\n" );
82 else
83 {
84 topCell = S->Next;
85 S->Next = topCell->Next;
86 free( topCell );
87 }
88 }
89
90 //打印栈的元素
91 void PrintStack( Stack S )
92 {
93 PtrToNode P;
94 for( P = S->Next; P != NULL; P = P->Next )
95 printf("%5d", P->Element);
96 printf("\n");
97 }
98
99 /****************************************/
100 int main()
101 {
102 ElementType data;
103 Stack st;
104 PtrToNode p;
105
106 if( !(st = CreateStack()) )
107 perror("create stack failed.\n");
108 else
109 printf("create stack success\n");
110
111 for( data = 10; data < 20; data++ )
112 Push( st, data );
113
114 printf("Push Operation: ");
115 PrintStack( st );
116
117 printf("Top Element = %5d\n", Top( st ));
118
119 Pop( st );
120 printf("Pop Operation: ");
121 PrintStack( st );
122
123 MakeEmpty( st );
124 DisposeStack( st );
125 return 0;
126 }
用数组实现栈结构，这种方法更加流行一些。因为，栈在应用过程中，任一时刻栈元素的实际个数并不会太大。因此，声明一个数组足够大而不至于浪费太多的空间，做到这一点并不困难。下面贴出数组实现的栈代码：
stackArray.h
1 #ifndef _STACKARRAY_H
2 #define _STACKARRAY_H
3
4 typedef int ElementType;
5 typedef struct _StackRecord
6 {
7 int TopOfStack;
8 int Capacity;
9 ElementType *Array;
10 }StackRecord;
11 typedef StackRecord *Stack;
12
13 int IsEmpty( Stack S );
14 int IsFull( Stack S );
15 Stack CreateStack( int MaxElements );
16 void DisposeStack( Stack S );
17 void MakeEmpty( Stack S );
18 void Push( Stack S, ElementType X );
19 ElementType Top( Stack S );
20 void Pop( Stack S );
21 ElementType TopAndPop( Stack S );
22 void PrintStack( Stack S );
23
24 #endif /* _STACKARRAY_H */
stackArray.c
1 /***************************************
2 * Stack Implentation by Array
3 * An popular method
4 * Author: qiqi
5 * Date: 2011-6-2
6 * *************************************/
7
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include "stackArray.h"
11
12 #define EmptyTOS ( -1 ) /* 当栈为空时，栈顶指针置为1 */
13 #define MinStackSize ( 5 ) /* 栈最小为5 */
14
15 //判断是否为空
16 int IsEmpty( Stack S )
17 {
18 return S->TopOfStack == EmptyTOS;
19 }
20
21 //判断栈是否已满
22 int IsFull( Stack S )
23 {
24 return S->TopOfStack == S->Capacity - 1;
25 }
26
27 //创建一个栈
28 Stack CreateStack( int MaxElements )
29 {
30 Stack S;
31
32 if( MaxElements < MinStackSize )
33 {
34 perror( "Stack size is too small!\n" );
35 exit(1);
36 }
37
38 S = ( Stack )malloc( sizeof( StackRecord ) );
39 if( S == NULL )
40 {
41 perror( "Out of space!!!\n" );
42 exit(1);
43 }
44
45 S->Array = ( ElementType * )malloc( sizeof( ElementType )
46 * MaxElements );
47 if( S->Array == NULL )
48 {
49 perror( "Out of space!!!\n" );
50 exit(1);
51 }
52
53 S->TopOfStack = -1;
54 S->Capacity = MaxElements;
55
56 return S;
57 }
58
59 //销毁一个栈
60 void DisposeStack( Stack S )
61 {
62 if( S != NULL )
63 {
64 free( S->Array );
65 free( S );
66 }
67 }
68
69 //清空一个栈
70 void MakeEmpty( Stack S )
71 {
72 S->TopOfStack = EmptyTOS;
73 }
74
75 //压栈操作
76 void Push( Stack S, ElementType X )
77 {
78 if( IsFull( S ) )
79 {
80 perror( "Stack is full!!!\n" );
81 exit( 1 );
82 }
83 else
84 S->Array[ ++S->TopOfStack ] = X;
85 }
86
87 //取栈顶元素
88 ElementType Top( Stack S )
89 {
90 if( !IsEmpty( S ) )
91 return S->Array[ S->TopOfStack ];
92 perror( "Stack is empty!!!\n" );
93 return 0; /* return value used to avoid warning */
94 }
95
96 //弹栈操作
97 void Pop( Stack S )
98 {
99 if( !IsEmpty( S ) )
100 {
101 S->TopOfStack--;
102 return;
103 }
104 else
105 {
106 perror( "Stack is empty!!!\n" );
107 exit( 1 );
108 }
109 }
110
111 //取栈顶元素，并弹栈操作
112 ElementType TopAndPop( Stack S )
113 {
114 if( !IsEmpty( S ) )
115 return S->Array[ S->TopOfStack-- ];
116 perror( "Stack is empty!!!\n" );
117 return 0; /* return value used to avoid warning */
118 }
119
120 //打印栈元素
121 void PrintStack( Stack S )
122 {
123 int i;
124 for( i = 0; i <= S->TopOfStack; i++ )
125 printf( "%5d", S->Array[ i ] );
126 printf( "\n" );
127 }
128
129
130 /****************************************/
131 int main()
132 {
133 Stack st;
134 ElementType data;
135 int i;
136
137 //创建栈
138 st = CreateStack( 10 );
139 //向栈中压入元素
140 for( data = 21; data < 29; data++ )
141 Push( st, data );
142 //打印栈中的元素
143 printf( "Stack : " );
144 PrintStack( st );
145 //取栈顶元素
146 printf( "Top of stack = " );
147 printf( "%5d\n", Top( st ) );
148 //弹出栈顶元素
149 Pop( st );
150 printf( "Pop stack: " );
151 PrintStack( st );
152 //取占栈顶元素，并打印之
153 printf( "Top and pop stack: " );
154 printf( "%5d\n", TopAndPop( st ) );
155 printf( "Stack: " );
156 PrintStack( st );
157 MakeEmpty( st );
158 DisposeStack( st );
159 }