栈

最新推荐文章于 2024-07-23 16:53:03 发布
最新推荐文章于 2024-07-23 16:53:03 发布
阅读量2.3k 收藏 10
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhhhyyyyy8/article/details/81033598
版权

定义：栈是限定在表尾进行插入和删除操作的线性表

允许插入和删除的一段称为栈顶(top)，另一端称为栈底(top)。栈是后进先出(Last In First Out)的线性表，简称LIFO结构。

一、顺序栈

当栈存在一个元素时，top等于0，因此通常把栈空的判定条件设定为top=-1。

顺序栈的动态数组实现：

//顺序栈，动态数组实现，感觉用的较少。和静态数组基本一样
#include<stdio.h>
 
#define true 1
#define false 0
#define STACK_INIT_SIZE 20
typedef int bool;
 
typedef struct SequenceStack
{
	int *data;
	int top;//用于栈顶指针。当栈为空时top=-1，栈满时top=MAXSIZE-1
}SqStack;
 
//初始化栈
bool InitStack(SqStack *s)
{
	s->data = (int*)malloc(sizeof(int)*STACK_INIT_SIZE);
	if (!s->data)
		exit(-1);
	s->top = -1;
	return 1;
}
 
//栈空判断，空返回1，非空返回0
bool StackEmpty(SqStack *s)
{
	if (s->top == -1)
		return true;
	else
		return false;
}
 
//栈的长度
int StackLength(SqStack *s)
{
	return s->top + 1;
}
 
//返回栈顶元素
bool StackGetTop(SqStack *s, int *val)
{
	if (s->top == -1)
		return false;
	*val = s->data[s->top];
	return true;
}
 
//入栈
//入栈时判断栈满
bool Push(SqStack *s, int val)
{
	if (s->top == STACK_INIT_SIZE - 1)
		return false;
	s->top++;
	s->data[s->top] = val;
	return true;
 
}
 
 
//出栈
//出栈，判断栈空
bool Pop(SqStack *s, int *val)
{
	if (s->top == -1)
		return false;
	*val = s->data[s->top];
	s->top--;
	return true;
}
 
//清栈
void StackClear(SqStack *s)
{
	
	s->top = -1;
}
 
//销毁栈
void StackDestroy(SqStack *s)
{
	free(s->data);
	s->data = NULL;
	s->top = -1;
}
 
//遍历栈
void StackTraverse(SqStack *s)
{
	for (int i = 0; i <= s->top; i++)
	{
		printf("%d ", s->data[i]);
	}
	printf("\n");
}
 
int main(void)
{
	SqStack s;
	//初始化栈
	InitStack(&s);
	//初始化栈之后，判断栈是否为空
	printf("初始化栈之后，判断栈是否为空:%d\n", StackEmpty(&s));
	printf("初始化栈之后，求栈的长度\:%d\n", StackLength(&s));
	//入栈几个元素
	Push(&s, 4);
	Push(&s, 1);
	Push(&s, 7);
	Push(&s, 2);
	//遍历栈
	printf("入栈之后，遍历栈\n");
	StackTraverse(&s);
	//出栈
	int val;
	Pop(&s, &val);
	printf("出栈元素为:%d\n", val);
	//遍历栈
	printf("出栈之后，遍历栈\n");
	StackTraverse(&s);
	//判断栈是否为为空
	printf("栈空否?%d\n", StackEmpty(&s));
	printf("栈长:%d\n", StackLength(&s));
	//获取栈顶元素
	StackGetTop(&s, &val);
	printf("栈顶元素为:%d\n", val);
	//清栈
	StackClear(&s);
	printf("清栈之后，栈空否？%d\n", StackEmpty(&s));
	return 0;
}


顺序栈的静态数组实现：

//栈的顺序存储结构，静态数组实现。感觉用的较多
#include<stdio.h>
 
#define true 1
#define false 0
#define MAXSIZE 20
typedef int bool;
 
typedef struct SequenceStack
{
	int data[MAXSIZE];
	int top;//用于栈顶指针。当栈为空时top=-1，栈满时top=MAXSIZE-1
}SqStack;
 
//初始化栈
bool InitStack(SqStack *s)
{
	s->top = -1;
	return 1;
}
 
//栈空判断，空返回1，非空返回0
bool StackEmpty(SqStack *s)
{
	if (s->top == -1)
		return true;
	else
		return false;
}
 
//栈的长度
int StackLength(SqStack *s)
{
	return s->top + 1;
}
 
//返回栈顶元素
bool StackGetTop(SqStack *s, int *val)
{
	if (s->top == -1)
		return false;
	*val = s->data[s->top];
	return true;
}
 
//入栈
//入栈时判断栈满
bool Push(SqStack *s, int val)
{
	if (s->top == MAXSIZE - 1)
		return false;
	s->top++;
	s->data[s->top] = val;
	return true;
 
}
 
 
//出栈
//出栈，判断栈空
bool Pop(SqStack *s, int *val)
{
	if (s->top == -1)
		return false;
	*val = s->data[s->top];
	s->top--;
	return true;
}
 
//清栈
void StackClear(SqStack *s)
{
	s->top = -1;
}
 
//遍历栈
void StackTraverse(SqStack *s)
{
	for (int i = 0; i <= s->top; i++)
	{
		printf("%d ", s->data[i]);
	}
	printf("\n");
}
 
int main(void)
{
	SqStack s;
	//初始化栈
	InitStack(&s);
	//初始化栈之后，判断栈是否为空
	printf("初始化栈之后，判断栈是否为空:%d\n", StackEmpty(&s));
	printf("初始化栈之后，求栈的长度\:%d\n", StackLength(&s));
	//入栈几个元素
	Push(&s, 4);
	Push(&s, 1);
	Push(&s, 7);
	Push(&s, 2);
	//遍历栈
	printf("入栈之后，遍历栈\n");
	StackTraverse(&s);
	//出栈
	int val;
	Pop(&s, &val);
	printf("出栈元素为:%d\n", val);
	//遍历栈
	printf("出栈之后，遍历栈\n");
	StackTraverse(&s);
	//判断栈是否为为空
	printf("栈空否?%d\n", StackEmpty(&s));
	printf("栈长:%d\n", StackLength(&s));
	//获取栈顶元素
	StackGetTop(&s, &val);
	printf("栈顶元素为:%d\n", val);
	//清栈
	StackClear(&s);
	printf("清栈之后，栈空否？%d\n", StackEmpty(&s));
	return 0;
}


二、链栈

在链栈中，一般不需要头结点，用top指针代替了链表中的头指针。注意链栈中元素之间指针的指向，跟链表是反过来的。

入栈：

对于链栈的入栈push操作，假设要入栈结点为s，元素值为e，top为栈顶指针。

出栈：

出栈p结点。

示意图：


链栈实现：

//栈，不带头结点
 
#include<stdio.h>
 
#define true 1
#define false 0
typedef int bool;
 
typedef struct StackNode
{
	int data;
	struct node *next;
}StackNode,*PStackNode;
 
typedef struct LinkStack
{
	int count;
	PStackNode top;
}LinkStack,*PLinkStack;
 
//初始化栈,成功返回1，失败返回0
void InitStack(PLinkStack s)
{
	s->top = NULL;
	s->count = 0;
	return;
}
 
//入栈,成功返回1，失败返回0
bool Push(PLinkStack s,int val)
{
	PStackNode pNew = (PStackNode)malloc(sizeof(StackNode));
	if (pNew == NULL)
	{
		return 0;
	}
	pNew->data = val;
	pNew->next = s->top;
	s->top = pNew;
	s->count++;
	return 1;
}
 
//出栈，成功返回1，失败返回0
bool Pop(PLinkStack s, int *val)
{
	if (s->top == NULL)
	{
		return 0;//栈空，出栈失败
	}
	PStackNode p = s->top;
	*val = s->top->data;
	s->top = s->top->next;
	free(p);
	s->count--;
	return 1;
}
 
//遍历
void StackTraverse(PLinkStack s)
{
	PStackNode p = (PStackNode)malloc(sizeof(StackNode));
	p = s->top;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
 
 
//获取栈顶元素
bool GetTop(PLinkStack s, int *val)
{
	if (s->top == NULL)
	{
		return 0;
	}
	*val = s->top->data;
	return 1;
}
 
//栈空判断
bool StackEmpty(PLinkStack s)
{
	if (s->top == NULL)
		return 1;
	else
		return 0;
}
 
//栈长
int StackLength(PLinkStack s)
{
	return s->count;
}
 
//清栈
void ClearStack(PLinkStack s)
{
	PStackNode p = s->top;
	while (p)
	{
		s->top = p->next;
		free(p);
		p = s->top;
 
	}
	s->count = 0;
}
 
 
int main(void)
{
	LinkStack s;
	//初始化栈
	InitStack(&s);
	//初始化栈之后，判断栈是否为空
	printf("初始化栈之后，判断栈是否为空:%d\n", StackEmpty(&s));
	//入栈
	Push(&s, 1);
	Push(&s, 2);
	Push(&s, 3);
	Push(&s, 4);
	//遍历栈
	printf("入栈之后，遍历栈:\n");
	StackTraverse(&s);
	//入栈之后，判断栈是否为空
	printf("入栈之后，判断栈是否为空:%d\n", StackEmpty(&s));
	//出栈
	int val;
	Pop(&s, &val);
	printf("出栈之后，遍历栈:\n");
	StackTraverse(&s);
	printf("出栈元素值为:%d\n", val);
	//求栈的长度
	printf("栈长：%d\n", StackLength(&s));
	//清栈
	ClearStack(&s);
	printf("清栈之后，判断栈是否为空:%d\n", StackEmpty(&s));
 
	return 0;
}

三、两栈共享空间

初始化：top=-1,top2=MAXSIZE;

//两栈共享空间，top1为栈1栈顶指针，初始化为-1；top2为栈2栈顶指针，初始化为MAXSIZE

#include<stdio.h>

typedef int bool;

#define true 1
#define false 0

#define MAXSIZE 100

typedef struct
{
	int data[MAXSIZE];
	int top1, top2;
}SqDoubleStack;

//初始化栈，top1=-1,top2=MAXSIZE
void InitStack(SqDoubleStack *s)
{
	s->top1 = -1;
	s->top2 = MAXSIZE;
}

//判断栈是否为空，是返回true，不是返回false，栈为空时top1==-1并且top2==MAXSIZE
bool StackEmpty(SqDoubleStack *s)
{
	if (s->top1 == -1 && s->top2 == MAXSIZE)
		return true;
	else
		return false;
}

//栈满
bool StackFull(SqDoubleStack *s)
{
	return s->top1 + 1 == s->top2;
}

//求栈的长度
int StackLength(SqDoubleStack *s)
{
	return s->top1 + 1 + MAXSIZE - s->top2;
}

//入栈,flag表示入栈1还是栈2
bool Push(SqDoubleStack *s, int flag, int key)
{
	//判断栈满
	if (s->top1 + 1 == s->top2)
		return false;
	if (flag == 1)
	{
		s->data[++s->top1] = key;
		return true;
	}
	else if (flag == 2)
	{
		s->data[--s->top2] = key;
		return true;
	}
	return false;//flag等于其他数
}

//出栈
bool Pop(SqDoubleStack *s, int flag, int *key)
{
	//栈1出栈
	if (flag == 1)
	{
		if (s->top1 == -1)
			return false;
		*key = s->data[s->top1--];
		return true;
	}
	else if (flag == 2)
	{
		if (s->top2 == MAXSIZE)
			return false;
		*key = s->data[s->top2++];
		return true;
	}
	return false;
}

//遍历栈
void StackTraverse(SqDoubleStack *s)
{
	for (int i = 0; i <= s->top1; i++)
		printf("%d ", s->data[i]);
	for (int j = s->top2; j <= MAXSIZE - 1; j++)
		printf("%d ", s->data[j]);
	printf("\n");
}


int main(void)
{
	SqDoubleStack s;
	InitStack(&s);
	printf("初始化栈后，栈是否为空:%d\n", StackEmpty(&s));
	printf("给栈1入几个元素\n");
	Push(&s, 1, 10);
	Push(&s, 1, 20);
	Push(&s, 1, 30);
	printf("给栈2入几个元素:\n");
	Push(&s, 2, 100);
	Push(&s, 2, 200);
	Push(&s, 2, 300);
	printf("遍历栈:\n");
	StackTraverse(&s);
	printf("栈长度为:%d\n", StackLength(&s));
	printf("栈1出栈\n");
	int key;
	Pop(&s, 1, &key);
	printf("出栈元素为:%d\n", key);
	printf("栈2出栈\n");
	Pop(&s, 2, &key);
	printf("出栈元素为:%d\n", key);
	printf("遍历栈:\n");
	StackTraverse(&s);
	return 0;
}

hhhhhyyyyy8
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】-顺序栈(初始化栈顶指针为-1）
RunningSnail的博客
07-22 5201
顺序栈-初始化栈顶指针为-11.头文件及类型定义2.顺序栈类型定义3.函数声明4.基本操作4.1 初始化顺序栈4.2 判空4.3 入栈4.4 出栈4.5 读取栈顶元素4.6 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #define MaxSize 10 #define ElemType int //定义顺序栈中元素的最大个数 using namespace std; 2.顺序栈类型定义 typedef struct { ElemType data
栈和队列---1顺序栈
qq_43228581的博客
01-16 302
@Adrian 顺序栈元素"入栈" 比如，还是模拟栈存储 {1,2,3,4} 的过程。最初，栈是"空栈"，即数组是空的，top 值为初始值 -1，如图 3 所示： 首先向栈中添加元素 1，我们默认数组下标为 0 一端表示栈底，因此，元素 1 被存储在数组 a[1] 处，同时 top 值 +1，如图 4 所示： 采用以上的方式，依次存储元素 2、3 和 4，最终，top 值变为 3，如图 5 所...
数据结构：栈
最新发布
2301_79601095的博客
07-23 1842
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
数据结构（三）——栈
L的博客
09-13 3142
一：栈的概述 栈是一个先进后出的线性表结构，只能在表尾(栈顶)进行插入、删除操作。例如软件中的撤销操作(先操作的后恢复，后操作的先恢复)、浏览器页面的后退按钮(先打开的后访问到，后打开的先访问到)，我们把允许插入和删除的一端称为栈顶，另一端称为栈底，插入操作称为入栈，删除操作称为出栈 定义说栈是一种线性表，它其实是一种特殊的线性表，它限制了插入、删除的位置 二：栈的顺序存储结构 用一段地址连...
数据结构--栈的相关知识点以及实现
铭
06-24 3164
参考：《数据结构--java语言描述》 栈是仅限在表尾（也就是栈顶）进行插入和删除操作的线性表。 允许插入和删除操作的一端称为栈顶(top)，另一端称之为栈底(button) 不含任何元素的栈称之为空栈。 假设栈S={a1 , a2, … , an},则称a1为栈元素， an为栈顶元素。由于入栈和出栈都是对栈顶元素进行操作，遵循后进先出（LIFO, last in first out）的原则，因此栈又称为后进先出的线性表 入栈和出栈是栈的两个主要操作，入栈和出栈操作都是对栈顶元素进行过操作。所..
栈——栈的定义及基本操作（初始化、判空、进栈、出栈、遍历栈、销毁栈等）
热门推荐
薛定谔的猫的博客
04-19 8万+
文章目录栈的定义栈的存储栈上的基本操作初始化判空操作进栈操作出栈操作读栈顶元素遍历栈销毁栈完整代码及实例共享栈 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。 栈的示意图： 栈顶Top：线性表允许插入和删除的那一端。 栈底Bottom：固定的，不允许进行插入和删除的另一端。  假设某个栈S={a1,a2, … ,an}，如上图所示，则a1为栈底元素，an为栈顶元素。由于只能在栈顶进行插入和删除操作，故进栈顺序为a1,a2, … ,an，出栈顺序为an, … ,a2,a1。故栈的操
LwIP协议栈源码详解.pdf
05-03
"LwIP协议栈源码详解" LwIP协议栈是 lightweight TCP/IP 协议栈的实现，它是一种轻量级、开源的嵌入式系统网络协议栈，广泛应用于嵌入式系统、物联网、自动化控制等领域。LwIP 协议栈的设计目标是提供一个小巧、...
两个栈空间共享，栈满打印
04-16
标题中的“两个栈空间共享，栈满打印”指的是在C++编程中实现一个特殊的栈结构，其中两个栈共享同一个内存空间。这个结构可以用于存储整数序列中的奇数和偶数，当任一栈达到其最大容量（即“栈满”状态）时，程序会...
Linux 中的各种栈：进程栈 线程栈 内核栈 中断栈
05-06
在Linux系统中，栈可以分为进程栈、线程栈、内核栈以及中断栈。 首先，我们需要了解栈（Stack）的基本概念。栈是一种后进先出（LIFO, Last In First Out）的数据结构，它允许数据被存储和检索，但只允许在一段称为...
数据结构栈的实验报告.doc
07-11
实验报告的主题是关于数据结构中的顺序栈的基本操作，主要涵盖了栈的初始化、进栈、出栈等核心概念。顺序栈是一种特殊的线性表，它的特点是只允许在一端进行插入和删除操作，这一端称为栈顶。 1. **栈的类型定义**...
数据结构顺序栈验证实验报告.pdf
07-11
数据结构中的顺序栈是一种特殊的线性表，它具有后进先出（LIFO）的特点，即最后进入的元素最先离开。在本实验报告中，学生通过编写C语言代码来理解和验证顺序栈的操作特性。 首先，实验的目标是让学生掌握栈的顺序...
栈的相关知识
weixin_47642634的博客
07-09 488
定义：只允许在一端插入和删除的线性表；遵循后进先出的原则（Last In First Out, LIFO）。可以类比为制作烤串和吃烤串。顺序栈：采用顺序存储的栈；利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针指向当前栈顶元素的位置。 栈顶指针：S.top ，初始值设置为 S.top = -1；栈顶元素：S.data[S.top]栈空条件：S.top == -1；栈满条件：S.top == MaxSize-1；栈长：S.top+1 进栈：栈不满时，栈顶指针先加1，再送值到栈顶元素。
数据结构之堆栈9一些补充
OVS98
09-29 721
1．栈 1.1 栈的定义 栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示： 结论：后进先出（Last In First Out），简称为LIFO线性表。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满： StackFull(S)、 进栈： Push(S,x)、
【数据结构】栈和队列详细分析（全）
码农研究僧的博客
05-05 1万+
前言 栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表， 其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。 栈的定义与特点 栈是限定仅在表尾进行插入或删除操作的线性表。 表尾称为栈顶,表头端称为栈底 。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的。 栈的操作 队列的定义与特点 和栈相反，队列是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素，允许插入的一端称为队尾，允许删除的一端则称为队头。 ...
关于栈顶指针初值为-1和0的区别
weixin_46475770的博客
02-25 1万+
关于栈顶指针初值为-1或者0 的区别(c语言) 栈顶指针：S.top 栈顶元素：S.data[S.top] 当栈顶指针的初始值设置 S.top=-1时 ps: 当栈为空时，栈顶指针指向data[-1],但栈底是data[0] top data{4} data{3} data{2} data{1} data{0} data{-1} … 进栈操作：栈不满时，栈顶指针先+1，在送值到栈顶元素 （通俗来讲：先给客人指路，客人才知道自己的座位在哪） S.top=S.
大话数据结构第四章栈的基本概念与出栈入栈操作
huibin.yun的博客
04-26 2207
一、栈的顺序存储结构 1.基本概念 栈顶就是表尾。 栈顶是栈插入和删除的地方。 栈就是只允许在表尾进行添加或删除，是顺序存储结构线性表的特例或者说简化。 为什么说是简化呢？相对于顺序存储结构来说栈只允许在表尾插入和删除，而顺序存储结构线性表是可以在任何位置插入和删除的。所以简化了，我固定位置了。 栈或者队列是固定插入和删除的位置的顺序存储结构的线性表。 具体区分： 栈是固定一端的位...
初始化栈的代码_面试官问我什么是栈，我随手画了10张图来解释
weixin_39671621的博客
11-20 394
来自公众号：技术让梦想更伟大栈的概念栈(stack)是限定仅在表的一端进行操作的数据结构，且栈是一种先进后出的数据结构，允许操作的一端称为栈顶，不允许操作的称为栈底，如下图所示：之前我们讲到了链表，我们只能够对其链表的表尾结点进行操作，并且只能进行插入一个新的结点与删除最末尾的这个结点两个操作，而这样强限制性的‘链表’，就是我们所说的栈。就像是一个死胡同一样，只有一个出口，如图所示，有个...
C语言实现栈操作：偶数栈与奇数栈
本资源是一份关于C语言编程的教程，重点讲述了如何使用栈（Stack）数据结构来实现一个特定的数据分类任务。标题“栈的操作--入栈出栈(C语言版)”明确指出了本文的核心内容是栈的基础操作，包括入栈（Push）和出栈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值