栈的实现

Posted 2020-10-30 laizhenghong2012

一 写在开头

1.1 本文内容

数据结构栈的实现。

 

二 栈的实现

不多说了，请直接看代码。

 1 // stack.h
 2 
 3 /* 为了使用bool */
 4 #include <stdbool.h>
 5 
 6 #ifndef _H_STACK_H
 7 #define _H_STACK_H
 8 
 9 /* 数据类型 */
10 typedef char type;
11 
12 /* 栈结点 */
13 typedef struct tsNode
14 {
15     type data;
16     struct tsNode *next;
17 } Node;
18 
19 /* 栈类型 */
20 typedef struct tsStack
21 {
22     Node *top;
23     unsigned int size;
24 } Stack;
25 
26 /* 初始化Stack */
27 Stack *
28 StackInit(void);
29 
30 /* 判断栈是否为空。为空返回true，否则返回false */
31 bool
32 IsEmpty(Stack *);
33 
34 /* 入栈操作 */
35 void
36 StackPush(Stack *, type);
37 
38 /* 出栈操作 */
39 type
40 StackPop(Stack *);
41 
42 /* 取得栈顶元素 */
43 type
44 GetTop(Stack *);
45 #endif

 

 1 // stack.c
 2 
 3 #include <stdio.h>
 4 #include <stdlib.h>
 5 #include <stdbool.h>
 6 #include "stack.h"
 7 
 8 /* 功能：栈初始化
 9  * 输入：无
10  * 输出：一个指向Stack型的指针，指针所指对象已被初始化
11  */
12 Stack *
13 StackInit(void)
14 {
15     Stack *s = NULL;
16 
17     s = (Stack *)malloc(sizeof(Stack));
18     if (s == NULL)
19         exit(EXIT_FAILURE);
20     s->top = NULL;
21     s->size = 0;
22     return s;
23 }
24 
25 /* 功能：判断栈是否为空。为空返回true，否则返回false
26  * 输入：一个指向Stack型的指针
27  * 输出：一个bool型变量
28  */
29 bool
30 IsEmpty(Stack *s)
31 {
32     /* s未被初始化 */
33     if (s == NULL)
34         exit(EXIT_FAILURE);
35     else
36         return ((s->size) == 0);
37 }
38 
39 /* 功能：入栈操作
40  * 输入：一个指向Stack型的指针，一个type型待入栈变量
41  * 输出：无
42  */
43 void
44 StackPush(Stack *s, type x)
45 {
46     Node *temp = (Node *)malloc(sizeof(Node));
47 
48     if (temp == NULL)
49         exit(EXIT_FAILURE);
50     temp->data = x;
51 
52     /* 若s未被初始化 */
53     if (s == NULL)
54         exit(EXIT_FAILURE);
55     temp->next = s->top;
56     s->top = temp;
57     s->size = (s->size) + 1;
58 }
59 
60 /* 功能：出栈操作
61  * 输入：一个指向Stack型的指针
62  * 输出：被出栈的元素
63  */
64 type
65 StackPop(Stack *s)
66 {
67     Node *p = NULL;
68     type r;
69 
70     if (IsEmpty(s))
71         exit(EXIT_FAILURE);
72     p = s->top->next;
73     r = s->top->data;
74     free(s->top);
75     s->top = p;
76     s->size = (s->size) - 1;
77     return r;
78 }
79 
80 /* 功能：返回栈顶元素
81  * 输入：一个指向Stack型的指针
82  * 输出：栈顶元素
83  */
84 type
85 GetTop(Stack *s)
86 {
87     if (IsEmpty(s))
88         exit(EXIT_FAILURE);
89     return s->top->data;
90 }

 

 1 #include <stdio.h>
 2 #include "stack.h"
 3 
 4 int main(int argc, char *argv[])
 5 {
 6     Stack *s = StackInit();
 7 
 8     /* test passed
 9     printf("s->top = %p\n", s->top);
10     printf("s->size = %u\n", s->size);
11     printf("s is empty: ");
12     IsEmpty(s) ? printf("yes\n") : printf("no\n");
13     */
14 
15     /* test passed
16     StackPush(s, ‘h‘);
17     StackPush(s, ‘e‘);
18     StackPush(s, ‘l‘);
19     StackPush(s, ‘l‘);
20     StackPush(s, ‘o‘);
21     printf("s is empty: ");
22     IsEmpty(s) ? printf("yes\n") : printf("no\n");
23     printf("s->size = %u\n", s->size);
24 
25     while ((s->size) > 0)
26     {
27         printf("%c\n", StackPop(s));
28     }
29     printf("s is empty: ");
30     IsEmpty(s) ? printf("yes\n") : printf("no\n");
31     */
32 
33     /* test passed
34     StackPush(s, ‘h‘);
35     StackPush(s, ‘e‘);
36     StackPush(s, ‘l‘);
37     StackPush(s, ‘l‘);
38     StackPush(s, ‘o‘);
39     while (IsEmpty(s) == false)
40     {
41         printf("%c\n", GetTop(s));
42         StackPop(s);
43     }
44     printf("s is empty: ");
45     IsEmpty(s) ? printf("yes\n") : printf("no\n");
46     */
47 
48     // 栈的内存组织情况 - pass
49     /* 当s为空栈时内存组织情况
50      * p s - 0x602010
51      * p s->top - 0x0
52      * p s->size - 0
53      */
54     
55     StackPush(s, ‘h‘);
56     /* 当s中有一个值为‘h‘的元素时内存组织情况
57      * p s - 0x602010
58      * p s->top - 0x602030
59      * p s->size - 1
60      * p s->top->data - ‘h‘
61      * p s->top->next - 0x0
62      */
63 
64     StackPush(s, ‘e‘);
65     /* 当s中有两个元素时内存组织情况
66      * p s - 0x602010
67      * p s->top - 0x602050
68      * p s->size - 2
69      * p s->top->data - ‘e‘
70      * p s->top->next - 0x602030
71      * p s->top->next->data - ‘h‘
72      * p s->top->next->next - 0x0
73      */
74 
75     StackPop(s);
76     /* 当将栈顶元素弹出后内存组织情况
77      * p s - 0x602010
78      * p s->top - 0x602030
79      * p s->size - 1
80      * p s->top->data - ‘h‘
81      * p s->top->next - 0x0
82      */
83     
84     return 0;
85 }

注意：为了成功编译包含了stack.h的主程序，你需要使用下面的命令。也即必须将stack.c编译成目标文件，供链接程序链接使用，否则链接程序将报错。不同于C标准库的使用，因为C标准库默认采用动态链接的方式，所用标准库中的函数均已经被编译好了，放在特定的目录下面，链接程序只需去目录中找相对应的目标文件即可。这里我们必须将stack.c编译成目标文件，供主程序链接时使用。

gcc main.c stack.c