定义
栈是限定只能在表尾删除和插入操作的线性表。
允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。
栈的插入操作称为进栈，也称压栈、入栈。
栈的删除操作称为出栈，也称弹栈。
栈的抽象数据结构
由于栈本身就是一个线性表，所以线性表的操作特性它都具备，针对它的特殊性，在它的操作上可能会有一些变化。将进栈和出栈分别改名为push和pop。
由于栈本身是一个线性表，所以线性表的顺序存储结构和链式存储结构同样适用于栈。
栈的链式存储框架搭建
链式栈的结点
typedef struct LINKNODE {
struct LINKNODE* next;
}LinkNode;
链式栈
typedef struct LINKSTACK {
LinkNode head;
int size;
}LinkStack;
构架搭建
//初始化栈 LinkStack *Init_LinkStack(); //入栈 void Push_LinkStack(LinkStack* stack, LinkNode* data); //返回栈顶元素 LinkNode* Top_LinkStack(LinkStack* stack); //出栈 void Pop_LinkStack(LinkStack* stack); //返回栈中元素个数 int Size_LinkStack(LinkStack* stack); //清空栈 void Clear_LinkStack(LinkStack* stack); //销毁栈 void FreeSpace_LinkStack(LinkStack* stack);
栈的链式存储框架实现
初始化栈
LinkStack *Init_LinkStack()
{
LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
stack->head.next = NULL;
stack->size = 0;
return stack;
}
入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data)
{
if (stack == NULL)
return ;
if (data == NULL)
return ;
data->next = stack->head.next;
stack->head.next = data;
stack->size++;
}
返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack)
{
if (stack == NULL)
return NULL;
if (stack->size == 0)
return NULL;
return stack->head.next;
}
出栈
void Pop_LinkStack(LinkStack* stack)
{
if (stack == NULL)
return;
if (stack->size == 0)
return;
//第一个有效结点
LinkNode* pNext = stack->head.next;
stack->head.next = pNext->next;
stack->size--;
}
返回栈中元素个数
int Size_LinkStack(LinkStack* stack)
{
if (stack == NULL)
return -1;
return stack->size;
}
清空栈
void Clear_LinkStack(LinkStack* stack)
{
if (stack == NULL)
return;
stack->head.next = NULL;
stack->size = 0;
}
销毁栈
void FreeSpace_LinkStack(LinkStack* stack)
{
if (stack == NULL)
return;
free(stack);
}
栈的链式存储框架测试
测试思路
创建栈
LinkStack *stack = Init_LinkStack();
创建数据
创建数据包括两步：创建结构体类型和数据初始化
创建结构体类型
typedef struct PERSON {
LinkNode node;
char name[64];
int age;
}Person;
数据初始化
Person p1, p2, p3, p4, p5;
strcpy(p1.name, "aaa");
strcpy(p2.name, "bbb");
strcpy(p3.name, "ccc");
strcpy(p4.name, "ddd");
strcpy(p5.name, "eee");
p1.age = 10;
p2.age = 20;
p3.age = 30;
p4.age = 40;
p5.age = 50;
入栈
Push_LinkStack(stack, (LinkNode*)&p1);
Push_LinkStack(stack, (LinkNode*)&p2);
Push_LinkStack(stack, (LinkNode*)&p3);
Push_LinkStack(stack, (LinkNode*)&p4);
Push_LinkStack(stack, (LinkNode*)&p5);
输出
while (Size_LinkStack(stack)>0)
{
//取出栈顶元素
Person* p = (Person*)Top_LinkStack(stack);
printf("Name:%s Age:%d\n", p->name, p->age);
//弹出栈顶元素
Pop_LinkStack(stack);
}
销毁栈
FreeSpace_LinkStack(stack);
运行结果
源码
LinkStack.h
1 #pragma once
2
3 #include<stdlib.h>
4 #include<stdio.h>
5
6 //链式栈的结点
7 typedef struct LINKNODE {
8 struct LINKNODE* next;
9 }LinkNode;
10
11 //链式栈
12 typedef struct LINKSTACK {
13 LinkNode head;
14 int size;
15 }LinkStack;
16
17 //初始化栈
18 LinkStack *Init_LinkStack();
19 //入栈
20 void Push_LinkStack(LinkStack* stack, LinkNode* data);
21 //返回栈顶元素
22 LinkNode* Top_LinkStack(LinkStack* stack);
23 //出栈
24 void Pop_LinkStack(LinkStack* stack);
25 //返回栈中元素个数
26 int Size_LinkStack(LinkStack* stack);
27 //清空栈
28 void Clear_LinkStack(LinkStack* stack);
29 //销毁栈
30 void FreeSpace_LinkStack(LinkStack* stack);
LinkStack.c
1 #include"LinkStack.h"
2
3 //初始化栈
4 LinkStack *Init_LinkStack()
5 {
6 LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
7 stack->head.next = NULL;
8 stack->size = 0;
9 return stack;
10 }
11 //入栈
12 void Push_LinkStack(LinkStack* stack, LinkNode* data)
13 {
14 if (stack == NULL)
15 return ;
16 if (data == NULL)
17 return ;
18 data->next = stack->head.next;
19 stack->head.next = data;
20 stack->size++;
21 }
22 //返回栈顶元素
23 LinkNode* Top_LinkStack(LinkStack* stack)
24 {
25 if (stack == NULL)
26 return NULL;
27 if (stack->size == 0)
28 return NULL;
29 return stack->head.next;
30 }
31 //出栈
32 void Pop_LinkStack(LinkStack* stack)
33 {
34 if (stack == NULL)
35 return;
36 if (stack->size == 0)
37 return;
38 //第一个有效结点
39 LinkNode* pNext = stack->head.next;
40 stack->head.next = pNext->next;
41 stack->size--;
42 }
43
44 //返回栈中元素个数
45 int Size_LinkStack(LinkStack* stack)
46 {
47 if (stack == NULL)
48 return -1;
49 return stack->size;
50 }
51 //清空栈
52 void Clear_LinkStack(LinkStack* stack)
53 {
54 if (stack == NULL)
55 return;
56 stack->head.next = NULL;
57 stack->size = 0;
58 }
59 //销毁栈
60 void FreeSpace_LinkStack(LinkStack* stack)
61 {
62 if (stack == NULL)
63 return;
64 free(stack);
65 }
main.c
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include<stdlib.h>
4 #include<stdio.h>
5 #include<string.h>
6 #include"LinkStack.h"
7
8 typedef struct PERSON {
9 LinkNode node;
10 char name[64];
11 int age;
12 }Person;
13
14 int main()
15 {
16 //创建栈
17 LinkStack *stack = Init_LinkStack();
18
19 //创建数据
20 Person p1, p2, p3, p4, p5;
21 strcpy(p1.name, "aaa");
22 strcpy(p2.name, "bbb");
23 strcpy(p3.name, "ccc");
24 strcpy(p4.name, "ddd");
25 strcpy(p5.name, "eee");
26 p1.age = 10;
27 p2.age = 20;
28 p3.age = 30;
29 p4.age = 40;
30 p5.age = 50;
31
32 //入栈
33 Push_LinkStack(stack, (LinkNode*)&p1);
34 Push_LinkStack(stack, (LinkNode*)&p2);
35 Push_LinkStack(stack, (LinkNode*)&p3);
36 Push_LinkStack(stack, (LinkNode*)&p4);
37 Push_LinkStack(stack, (LinkNode*)&p5);
38
39 //输出
40 while (Size_LinkStack(stack)>0)
41 {
42 //取出栈顶元素
43 Person* p = (Person*)Top_LinkStack(stack);
44 printf("Name:%s Age:%d\n", p->name, p->age);
45 //弹出栈顶元素
46 Pop_LinkStack(stack);
47 }
48 //销毁栈
49 FreeSpace_LinkStack(stack);
50
51 return 0;
52 }
原文地址：https://www.cnblogs.com/lixuejian/p/10881429.html
时间： 2024-10-11 04:08:50