栈 知识点

已于 2022-04-10 16:12:30 修改
阅读量740 收藏
点赞数
文章标签： 数据结构
于 2022-04-09 22:00:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41508779/article/details/124067704
版权
本文详细介绍了栈这种数据结构，包括其基本概念、顺序存储和链式存储的实现方式。顺序栈使用静态数组实现，初始化时top设为-1或0，进栈、出栈、读栈顶元素的操作以及如何判断栈空栈满。链式栈则分为不带头结点和带头结点两种情况。此外，文章还提及了共享栈的概念，以及栈的销毁过程。
摘要由CSDN通过智能技术生成

文章目录

栈的基本概念

线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长。
栈是只允许在栈顶进行插入或删除操作的线性表
在这里插入图片描述
如洗的盘子和 插肉串
在这里插入图片描述
栈顶：允许插入和删除的一端
栈底：不允许插入和删除的一端
在这里插入图片描述
特点：后进先出 Last In First Out(LIFO)

栈的基本操作
在这里插入图片描述
如果出栈操作和进展操作交叉进行，则会有多种出栈顺序。
n个不同的元素进栈，出栈元素不同排列的个数为
在这里插入图片描述

栈的顺序存储实现

顺序存储，用静态数组实现，并需要记录栈顶指针
顺序栈：用顺序存储方式实现的栈
基本操作：

  1. 创（初始化）
  2. 增（进栈）
  3. 删（出栈）
  4. 查（获取栈顶元素）
  5. 判空、判满

顺序栈的定义

#define MaxSize 10		//栈中元素的最大个数 
typedef struct{
	int data[MaxSize];	//静态数组存放栈中元素	 
	int top;			//栈顶指针 
}SqStack;				//sq:sequence
 
void InitStack(SqStack &S){
	S.top=-1;
}

bool StackEmpty(SqStack S){
	return (S.top==-1);
}

int main(){
	SqStack S;
	InitStack(S);
}

top指向栈顶元素，如果此时存入了五个元素，则top=4.（数组下标）
top指针不能指向0，因为此时data[0]还没有储存元素，因此可以把top的值设为负一。
要判断栈是否为空，只要看top的值是否为负一即可。
在这里插入图片描述

进栈操作

首先要判断栈是否已满，然后将指针加1，令新元素入栈
在这里插入图片描述

#define MaxSize 10		//栈中元素的最大个数 
typedef struct{
	int data[MaxSize];	//静态数组存放栈中元素	 
	int top;			//栈顶指针 
}SqStack;				//sq:sequence
 
void InitStack(SqStack &S){
	S.top=-1;
}

bool StackEmpty(SqStack S){
	return (S.top==-1);
}

bool Push(SqStack &S,int x){	//新元素入栈 
	if(S.top==MaxSize-1)	//栈满 
		return false;
	S.top=S.top+1;			//指针先加1 
	S.data[S.top=x];		//新元素入栈 
	//更简洁的写法：
	//S.data[++S.top]=x;
	return true; 
}

int main(){
	SqStack S;
	InitStack(S);
	Push(S,1); 
}

出栈操作

Pop(SqStack &S,int &x)中x有&，
出栈函数的调用者首先会在自己得函数里面定义一个变量，存放在内存中的某一个位置，加了引用符号后，在出栈操作里面的变量x和函数调用者定义的x对应的是同一份数据而不是复制品。
在这里插入图片描述

#define MaxSize 10		//栈中元素的最大个数 
typedef struct{
	int data[MaxSize];	//静态数组存放栈中元素	 
	int top;			//栈顶指针 
}SqStack;				//sq:sequence
 
void InitStack(SqStack &S){
	S.top=-1;
}

bool Pop(SqStack &S,int &x){
	if (S.top==-1)	//栈空，报错 
		return false;
	x=S.data[S.top];	//栈顶元素先出栈
	S.top=S.top-1;	//指针再减1 
	//等价于
	//x=S.data[S.top--]; 
	return true; 
}

删除后数据还残留在内存中，只是逻辑上被删除了。
x=S.data[–S.top];等价于 S.top=S.top-1; x=S.data[S.top];

读栈顶操作

与出栈操作几乎一样，只是top不用- -

#define MaxSize 10		//栈中元素的最大个数 
typedef struct{
	int data[MaxSize];	//静态数组存放栈中元素	 
	int top;			//栈顶指针 
}SqStack;				//sq:sequence

bool GetTop(SqStack S,int &x){
	if(S.top==-1)
		return false;
	x=S.data[S.top]	;		//x记录栈顶元素
	return true; 
}

另一种方式 top=0而不是-1

top指针初始指向0,此时指向了下一个可以插入元素的位置
在这里插入图片描述
在这里插入图片描述

#define MaxSize 10		//栈中元素的最大个数 
typedef struct{
	int data[MaxSize];	//静态数组存放栈中元素	 
	int top;			//栈顶指针 
}SqStack;				//sq:sequence
 
void InitStack(SqStack &S){
	S.top=0;		//初始化栈顶指针指向0 
}

bool StackEmpty(SqStack S){
	return (S.top==0);
}

bool Push(SqStack &S,int x){	//新元素入栈 
	if(S.top==MaxSize)	//栈满 
		return false;
	S.data[S.top++]=x;
	return true; 
}

bool Pop(SqStack &S,int &x){
	if (S.top==0)	//栈空，报错 
		return false;
	x=S.data[--S.top]; 
	return true; 
} 

bool GetTop(SqStack S,int &x){
	if(S.top==0)
		return false;
	x=S.data[S.top]	;		//x记录栈顶元素
	return true; 
}

int main(){
	SqStack S;
	InitStack(S);
	Push(S,1); 
}

共享栈

顺序栈的缺点：栈的大小不可变
共享栈：两个栈共享同一片存储空间
栈满的条件：top0+1==top1
在这里插入图片描述
往0号栈放入数据元素，栈顶是从下往上依次递增
往1号栈放入数据元素，栈顶是从上往下依次递增
在这里插入图片描述

#define MaxSize 10		//栈中元素的最大个数 
typedef struct{
	int data[MaxSize];	//静态数组存放栈中元素	 
	int top0;			//0号栈栈顶指针 
	int top1;			//1号栈栈顶指针 
}ShStack; 
 
void InitStack(SqStack &S){
	S.top0=0;		//初始化栈顶指针
	S.top1=MaxSize;
}

销毁顺序栈

1.逻辑上清空一个栈 令top=-1 指向初始化的位置
2.回收这个栈所占用的内存资源 使用的是变量声明分配内存空间，没有使用malloc函数，故函数运行结束后系统自动回收内存。

在这里插入图片描述

栈的链式存储实现

出栈/进栈都只能在栈顶一端进行（链头作为栈顶）

typedef struct LinkNode{
	int data;			//数据域 
	struct LinkNode *next;	//指针域 
}*LiStack;				//栈类型定义

栈的基本操作：

  • 初始化
  • 进栈
  • 出栈
  • 获取栈顶元素
  • 判空、判满

不带头结点：

#include<stdio.h>
#include<stdlib.h> 
#include<assert.h>

typedef struct LinkNode{
	int data;			//数据域 
	struct LinkNode *next;	//指针域 
}Linode,*LiStack;				//栈类型定义 

//初始化 
bool InitStack(LiStack &L){		
	L=NULL;		//防止脏数据 
	return true;
}

//判空 
bool isEmpty(LiStack L){
	return (L==NULL);
} 

//进栈
void PushStack(LiStack &L){
	int x;
	scanf("%d",&x);
	while(x!=9999){
		Linode *p=(Linode *)malloc(sizeof(Linode));
		assert(p);
		p->data=x;
		p->next=L;	//不带头结点 
		L=p;
		scanf("%d",&x);
	}
}
//出栈 
bool PopStack(LiStack &L,int &x){
	Linode *p;
	if(L){
		p=L;
		x=p->data;
		L=L->next;
		free(p);
		return true;
	}
	return false;
}
//获取栈顶元素 
bool GetStack(LiStack &L,int &x){
	if(L){
		x=L->data;
		return true;
	}
	return false;
}
//求表长
int StackLength(LiStack L)
{
    int count = 0;
    Linode *p=L;
    while (p)
    {
        count++;
        p = p->next;
    }
    return count;
}

//打印链栈
void PrintStack(LiStack L){
	if(L){
		while(L){
			printf("%d ",L->data);
			L=L->next;
		}
		printf("\n");
	}
} 
 
int main(){
	LiStack L;
	InitStack(L);
	printf("%d\n",isEmpty(L));
	PushStack(L);
	int x;
	int a;
	printf("%d\n",PopStack(L,x));
	printf("%d\n",x);
	printf("%d\n",GetStack(L,a));
	printf("%d\n",a);
	printf("%d\n",StackLength(L));
	PrintStack(L);
}

带头结点：

#include<stdio.h>
#include<stdlib.h> 
#include<assert.h>

typedef struct LinkNode{
	int data;			//数据域 
	struct LinkNode *next;	//指针域 
}Linode,*LiStack;				//栈类型定义 

//初始化 
bool InitStack(LiStack &L){		
	L=(Linode *)malloc(sizeof(Linode));
	if(L==NULL){
		return false;
	}
	L->next=NULL;		//防止脏数据 
	return true;
}

//判空 
bool isEmpty(LiStack L){
	return (L->next==NULL);
} 

//进栈
void PushStack(LiStack &L){
	int x;
	scanf("%d",&x);
	while(x!=9999){
		Linode *p=(Linode *)malloc(sizeof(Linode));
		assert(p);
		p->data=x;
		p->next=L->next;	//带头结点 
		L->next=p;
		scanf("%d",&x);
	}
}
//出栈 
bool PopStack(LiStack &L,int &x){
	Linode *p;
	if(L){
		p=L->next;
		x=p->data;
		L->next=L->next->next;
		free(p);
		return true;
	}
	return false;
}
//获取栈顶元素 
bool GetStack(LiStack &L,int &x){
	if(L){
		x=L->next->data;
		return true;
	}
	return false;
}
//求表长
int StackLength(LiStack L)
{
    int count = 0;
    Linode *p=L->next;
    while (p)
    {
        count++;
        p = p->next;
    }
    return count;
}

//打印链栈
void PrintStack(LiStack L){
	if(L){
		while(L){
			printf("%d ",L->next->data);
			L->next=L->next->next;
		}
		printf("\n");
	}
} 
 
int main(){
	LiStack L;
	InitStack(L);
	printf("%d\n",isEmpty(L));
	PushStack(L);
	int x;
	int a;
	printf("%d\n",PopStack(L,x));
	printf("%d\n",x);
	printf("%d\n",GetStack(L,a));
	printf("%d\n",a);
	printf("%d\n",StackLength(L));
	PrintStack(L);
}
静静www
关注
【数据结构入门精讲 | 第五篇】栈知识点及考研408、企业面试练习
等风来
12-23 2783
栈是限定仅在栈顶（即表首）进行插入和删除操作的线性表，也称为后进先出（Last In First Out） 的线性表，简称 LIFO 结构。 栈的内部实现原理其实就是数组或链表的操作，而之所以引入 栈 这个概念，是为了将程序设计问题模型化，利用栈的先进后出特性对特定的一些问题进行简化。（栈是线性表的特例） 允许插入和删除元素的一端称为栈顶，另一端称为栈底，不含任何任何数据元素的栈称为空栈。
栈知识点总结（一）：使用数组和链表实现栈
Melonl的博客
11-21 1451
前言 栈是一种只能在一端进行插入或删除的线性数据结构，栈的主要特点是后进先出（Last In First Out, FIFO），即后进栈的元素先出栈。栈的应用很广泛，常见的应用场景例如表达式的括号匹配、文本编辑器的撤销功能、以及一些需要将有序数据逆序的场景都需要用到栈。栈的实现较为简单，并且可以由两种数据结构：链表、数组来实现，这篇文章要讲的就是如何用数组和链表来实现一个栈，同时简单讲讲两种实现...
数据结构笔记——栈
Wmiracle的博客
10-31 1053
本篇包括栈的类型定义、顺序栈和链栈的代码实现，内容综合各方资料及本人的理解将栈最基础的理论整合而成。
创建栈的三种形式
05-14
这个Demo主要讲解了,建立Stack的三种形式, 希望可以帮助需要的同学.
数据结构——栈的讲解（超详细）
最新发布
effort123_的博客
08-10 4499
小编也是完成了对于栈的讲解，总体来说，栈这个数据结构小编自己认为是不算太难的（关于栈的习题不算），本篇文章算是小编最近写的最短的一篇了，希望读者朋友可以去好好的了解，如果文章有什么错误的地方，请在评论区指出，小编一定及时更正，那么我们下篇文章见啦！
栈的知识点
qq_43310396的博客
02-12 752
栈：只允许在一段进行插入或删除操作。 栈顶：栈中允许进行插入和删除的那一端。 操作特点：后进先出 顺序栈 注：1.top值不能超过最大值max 2.空栈的判定条件通常为top==-1，满栈的判定条件通常为top=max-1，栈中数据元素个数为top+1 顺序栈操作 1.判空： bool empty（stack s） { if（s.top==-1) return tru...
堆、栈知识点
flyingfish
12-19 544
学习堆、栈和堆栈。。。。。。。要点： 堆：顺序随意 栈：先进后出 堆和栈的区别  一、预备知识—程序的内存分配  一个由c/C++编译的程序占用的内存分为以下几个部分  1、栈区（stack）— 由编译器自动分配释放 ，存放**函数的参数值，局部变量的值**等。其操作方式类似于数据结 构中的栈。  2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可  在计算机领域，堆栈是
文件的类型为xmind，内容是技术栈知识点
03-28
xmind文档
java各个技术栈相关知识点
05-23
在Java各个技术栈中，涵盖了许多关键的知识点，包括基础语法、面向对象编程、集合框架、多线程、网络编程、I/O流、数据库操作、异常处理、反射机制、垃圾回收等。下面将对这些知识点进行详细阐述。 1. **基础语法**...
数据结构——栈知识总结
qq_43215434的博客
11-10 840
一、栈 1、栈的逻辑结构 栈：限定仅在表尾进行插入和删除操作的线性表。 空栈：不含任何数据元素的栈。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的操作特性：后进先出。 ADT Stack Data 栈中元素具有相同类型及后进先出特性， 相邻元素具有前驱和后继关系 Operation InitStack 前置条件：栈不存在 ...
栈相关知识点
weixin_44699133的博客
10-26 202
栈(stack) 分类 概念及特点 基本结构 生活中的案例 相关操作 分类 顺序栈 单链栈 概念 操作在某一端受到限制,且有按一定顺序来进行的叫栈 特点 1. 操作(插入和删除)仅能在某一端进行 2. 并且相关操作,都遵循先进后出,后进先出 基本结构 1. 栈底(base):不能进行插入,删除的一端 2. 栈顶(top):可以进行插入,删除的一端(可以变化的) 生活案例 1. 放取盘子 2. 火车进站 拿火车进站来说 ...
栈的知识点总结
Lookdrama的博客
11-02 1330
栈(stack)是一个特殊的线性表，是限定仅在一端（通常是表尾)，进行插入和删除操作的线性表。·又称为后进先出(Last In First Out)的线性表，简称LIFO结构。·栈的逻辑结构与线性表相同，仍为一对一的关系。
栈知识点及应用
weixin_44123181的博客
02-17 664
栈
关于栈部分知识点
weixin_30735745的博客
05-23 149
作业连接 第一个作业 面向对象-四则运算 github 具体代码在面向对象四则运算文件夹中 对于栈的学习探索 栈的特点： 栈的存储方式是先进后出的方式，类似生活中的电梯 在代码中，有类似特点的就是递归函数吧。 栈的定义： 需要头文件 #include < stack > 定义： stack < T > sta; T为类型 sta为变量名--同下 栈的操作： 入栈： sta...
栈的基础知识总结
qq_43404873的博客
11-05 1611
栈的介绍 栈是一个先入后出的有序列表 栈中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top),另一端为固定的一端，称为栈底(Bottom) 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除 栈的快速入门 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存储栈的数据内容 数组模拟栈思路如下 定义一个top来表示栈顶，初始化为-1 入栈的操作，
【数据结构】 栈的知识点
weixin_59215611的博客
09-24 1087
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。栈中的数据元素遵守LIFO（）的原则。压栈：栈的插入操作叫做进栈/压栈/入栈，。出栈：栈的删除操作叫做出栈。
栈知识点笔记
weixin_44828370的博客
09-23 277
文章目录栈一、栈1. 定义2. 顺序存储结构代码实现3. 链式存储结构4. 栈的重要应用-递归5. 栈的应用-四则运算 栈 左轮手枪和弹夹手枪，臭弹 栈是限定仅在表尾进行插入和删除操作的线性表。 队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。 一、栈 1. 定义 先进后出，后进先出！ ADT 栈 stack Data 同线性表。相同类型、相邻元素具有前驱和后继关系！ Operation InitStack(*S) 初始化操作，建立一个空栈S DestroySt
计算机网络知识点整理与期末复习指南
资源摘要信息:"这是一份针对计算机网络课程的知识点复习笔记，从物理层到应用层，系统地整理了各层的重点内容。笔记中综合了王道考研计算机网络习题书，并对考点进行了分析和总结，便于读者了解哪些内容是常考点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值