【数据结构与算法】第三章 栈c实现，使用链表结构
栈的本质是一个表，但它限制插入和删除只能在一个位置上进行。这个特殊的位置是表的末端，叫做栈顶(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
}