堆栈的线性链表表示程序(C语言)

堆栈

堆栈是一个只允许在表的一边进行插入或删除操作的线性表。

有很多问题都依赖堆栈,离开堆栈甚至都不可能得到解决。

堆栈的线性链表表示

堆栈有基本操作(线性)

  • 创建堆栈
  • 检测是否为空
  • 检测表长
  • 插入操作
  • 取栈顶元素
  • 删除操作
  • 销毁堆栈

测试代码

下面我们开始测试代码

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<time.h>
 4 
 5 
 6 typedef struct Stack
 7 {
 8     int data;
 9     struct Stack *Slink;
10 }Sta, *Stack;
11 
12 
13 Stack Stack_INTEN( );        //初始化堆栈
14 int Stack_EMPTY(Stack );        //测试堆栈是否为空
15 int Stack_LEN(Stack );            //测试堆栈的长度
16 Stack Stack_PUSH(Stack , int );    //从栈顶插入一个数
17 Stack Stack_PULL(Stack , int *);//从栈顶取出一个元素并删除栈顶元素
18 Stack Stack_DELE(Stack );        //删除栈顶元素
19 int Stack_FREE(Stack );            //销毁栈
20 void Stack_SHOW(Stack );        //显示栈中所有元素

“Link_Stack.h”

这是其中一个头文件里面存放了一些函数声明,一个结构体声明,还有包含头文件







 1 #include"Link_Stack.h"
 2 
 3 
 4 Stack Stack_INTEN()                //初始化链表top为NULL
 5 {
 6 
 7     return  NULL;                                        
 8 }
 9 
10 
11 int Stack_EMPTY(Stack top)
12 {
13     return (top == NULL);
14 }
15 
16 int Stack_LEN(Stack top)                    //利用遍历计算连表的长度
17 {
18     int i = 0;
19     Stack p = top;
20     while (p != NULL)                                        
21     {
22         p = p->Slink;
23         i++;
24     }
25     return i;                                //返回链表的长度
26 }
27 
28 Stack Stack_PUSH(Stack top, int n)            //插入数据
29 {
30     Stack p;
31     if (!(p = (Stack)malloc(sizeof(Sta))))    //创建一个新结点,并判断是否成功
32     {
33         puts("It's creat error!");
34         return top;
35     }
36     p->data = n;
37     p->Slink = top;
38     top = p;
39     return top;    
40 }
41 
42 Stack Stack_PULL(Stack top, int *n)            //出栈操作
43 {
44     Stack p;
45     if (Stack_EMPTY(top))
46     {
47         puts("It's empty!Error!!");
48         return top;
49     }
50     *n = top->data;                                            
51     p = top;
52     top = top->Slink;
53     free(p);                                //释放空间
54     return top;    
55 }
56 
57 Stack Stack_DELE(Stack top)                    //删除栈顶元素
58 {
59     Stack p;
60     if (Stack_EMPTY(top))
61     {
62         puts("It's empty!Error!");
63         return top;
64     }
65     p = top;
66     top = top->Slink;
67     free(p);
68     return top;
69 }
70 
71 int Stack_FREE(Stack top)                    //销毁一个栈
72 {
73     Stack p;
74     while (!Stack_EMPTY(top))
75     {
76         p = top;
77         top = top->Slink;
78         free(p);
79     }
80     puts("All the Stack is clean out!");
81     return 1;
82 }
83 
84 
85 
86 void Stack_SHOW(Stack top)                    //输出栈中所有元素
87 {
88     Stack p = top;
89     while (p != NULL)
90     {
91         printf("%5d", p->data);
92         p = p->Slink;
93     }
94     puts("");
95 }
 

“method.c”

这是实现堆栈基本操作的一些函数。

下面就是一些堆栈线性链表基础操作的测试。

 1 #include"Link_Stack.h"
 2 
 3 
 4 int main(void)
 5 {
 6     int num;                            //声明变量
 7     int *p = &num;
 8     int len;
 9     Stack top ;
10     
11     
12    top=Stack_INTEN()                    //初始化
13 
14 
15     for (int i = 0; i < 10; i++)
16     {
17         
18         top=Stack_PUSH(top, i);            //一次入栈一个数据,循环10次,并显示入栈后的数据
19     }
20     Stack_SHOW(top);
21 
22 
23 
24     top=Stack_PUSH(top, 1000);            //入栈一次,并显示效果
25     Stack_SHOW(top);
26     puts("");
27 
28 
29 
30 
31     top = Stack_PULL(top, p);            //出栈并显示出栈的元素
32     printf("The top element is %d\n", *p);
33     puts("");
34 
35 
36     len = Stack_LEN(top);                //求出长度并显示长度
37     printf("The length is %d",len);
38     puts("");
39 
40 
41 
42     for (int i = 0; i < 3; i++)            //删除部分元素并显示剩余元素
43         top = Stack_DELE(top);
44     Stack_SHOW(top);
45     puts("");
46 
47 
48 
49     Stack_FREE(top);                    //销毁栈
50     if (!top)
51         puts("Error!");
52     return 0;
53 }

为了让界面更人性化
在这里插入图片描述
人为加入了些换行操作。
下面是测试结果
在这里插入图片描述
其实在一开始写的时候,我看完了书之后发现挺简单的,所以没有去管他觉得很简单就没有去写测试。之后我写堆栈的符号匹配检查的时候,就一直都在出问题,忙活了好久最后发现我在写堆栈的时候出了问题,就回来重新对堆栈实现写一个测试小程序。

C语言和c++不同,它没有引用类型。在之前的单链表中并没有涉及到第一个链节点指针list的变化,而在堆栈的入栈出栈中,都涉及到栈顶指针的变化,由于惯性思维并没有考虑到这个问题…

嗝~

同步更新在csdn:codeloop

猜你喜欢

转载自www.cnblogs.com/codeloop/p/11765802.html