栈

最新推荐文章于 2024-05-04 22:28:16 发布
最新推荐文章于 2024-05-04 22:28:16 发布
阅读量448 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43728862/article/details/117187532
版权
本文详细介绍了栈的顺序存储结构，包括初始化时栈顶指针指向-1和0的两种情况，以及如何实现进栈、出栈、读取栈顶元素等操作。同时，展示了共享栈的概念，以及栈在十进制转二进制和判断回文数问题中的应用。此外，还探讨了链栈的存储结构，包括带头结点和不带头结点的实现。最后，总结了链栈和顺序栈在时间和空间复杂度上的优缺点，并指出选择栈类型的原则。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

栈

定义

栈是一种受限的线性表,栈的逻辑结构任然是一对一的关系,但只能在栈顶进行插入和删除
特点:是先进去的最后出来
在这里插入图片描述

栈的顺序存储结构

初始化的时候栈顶指针指向-1

在这里插入图片描述

//栈
//顺序栈:此时top 指向 -1 
#include <stdio.h>
#include <stdlib.h> 
#define MaxSize 20
typedef struct{
	int data[MaxSize];//存储栈元素 
	int top;//栈顶指针：指向栈顶的 
}SqStack;
//初始化
bool InitStack(SqStack &s){
	s.top = -1;
	return true;
} 
//判断栈是否为空
bool StackEmpty(SqStack s){
	if(s.top == -1){
		return true;
	}else{
		return false;
	}
} 
//进栈
bool Push(SqStack &s,int e){
	if(s.top == MaxSize - 1){
		return false;
	}
	s.top += 1;
	s.data[s.top] = e;
	return true;
} 
//读取栈顶元素
bool GetTop(SqStack s,int &e){
	if(s.top == -1){
		return false; 
	}
	e = s.data[s.top];
	return true;
} 
//出栈
bool Pop(SqStack &s,int &e){
	if(s.top == -1){
		return false;
	}
	e = s.data[s.top];
	s.top -= 1;
	return true; 
} 
int main(){
	SqStack s;
	int e;
	int e1;
	int e2;
	if(InitStack(s)){
		printf("初始化成功\n");
		printf("请输入,入栈元素:");
		scanf("%d",&e);
		if(Push(s,e)){
			printf("添加成功\n");
		}else{
			printf("添加失败\n");
		}
		if(GetTop(s,e2)){
			printf("删除成功,此时的删除的元素为:%d\n",e2);
		}
		if(Pop(s,e2))
		if(StackEmpty(s)){
			printf("此时栈为空");
		}else{
			printf("此时栈不为空");
		}
	} 
	return 0;
}

初始化的时候栈顶指针指向0

在这里插入图片描述

//栈
//顺序栈:此时top 指向 0
#include <stdio.h>
#include <stdlib.h> 
#define MaxSize 20
typedef struct{
	int data[MaxSize];//存储栈元素 
	int top;//栈顶指针：指向栈顶的 
}SqStack;
//初始化
bool InitStack(SqStack &s){
	s.top = 0;
	return true;
} 
//判断栈是否为空
bool StackEmpty(SqStack s){
	if(s.top == 0){
		return true;
	}else{
		return false;
	}
} 
//进栈
bool Push(SqStack &s,int e){
	if(s.top == MaxSize){
		return false;
	}
	
	s.data[s.top] = e;
	s.top += 1;
	return true;
} 
//读取栈顶元素
bool GetTop(SqStack s,int &e){
	if(s.top == 0){
		return false; 
	}
	e = s.data[s.top - 1];
	return true;
} 
//出栈
bool Pop(SqStack &s,int &e){
	if(s.top == 0){
		return false;
	}
	s.top -= 1;
	e = s.data[s.top];
	
	return true; 
} 
int main(){
	SqStack s;
	int e;
	int e1;
	int e2;
	if(InitStack(s)){
		printf("初始化成功\n");
		printf("请输入,入栈元素:");
		scanf("%d",&e);
		if(Push(s,e)){
			printf("添加成功\n");
		}else{
			printf("添加失败\n");
		}
		if(GetTop(s,e2)){
			
		}
		if(Pop(s,e2)){
			printf("删除成功,此时的删除的元素为:%d\n",e2);
			
		}
		if(StackEmpty(s)){
			printf("此时栈为空");
		}else{
			printf("此时栈不为空");
		}
	} 
	return 0;
}

共享栈

出现的背景:一个栈我们必须提前声明她的空间大小,当对于两个相同类型的栈,我们却可以做到最大限度地利用空间,思路:是在数组的两端，向中间靠拢

//共享栈
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 20
typedef struct{
	int data[MaxSize];
	int top1;//栈1的栈顶指针
	int top2;//栈2的栈顶指针
}SqStack; 
//初始化
bool InitSqStack(SqStack &s){
	s.top1 = -1;
	s.top2 = MaxSize;
} 

int main(){
	SqStack s;
	return 0;
}
//栈满的：s.top2 - s.top1 = 1

栈的顺序存储的应用

十进制转二进制

#include <stdio.h>
#define MaxSize 20
typedef struct{
	int data[MaxSize];
	int top;
}Stack; 
//初始化
bool InitStack(Stack &s){
	s.top = -1;
	return true;
	
} 
//入栈
bool push(Stack &s,int e){
	if(s.top == MaxSize - 1){
		return false;
	}
	s.top += 1;
	s.data[s.top] = e;
	return true;
} 
//出栈
bool pop(Stack &s,int &e){
	if(s.top == -1){
		return false;
	}
	e = s.data[s.top];
	s.top -= 1;
	return true;
} 
//显示栈中的元素
int StackPrint(Stack s){
	if(s.top == -1){
		return 0;
	}
	while(s.top != -1){
		printf("%d",s.data[s.top]);
	    s.top -= 1;
	}
	
} 
int main(){
	Stack s;
	int sum;
	int e,i;
	if(InitStack(s)){
		printf("初始化成功\n");
		printf("请输入一个十进制的数:");
		scanf("%d",&sum);
		while(sum){
			e = sum % 2;//辗转相除法 
			push(s,e);//余数进栈 
			sum = sum / 2;
		}
		printf("对应的二进制:");
		StackPrint(s);
		
	}
	return 0;
}

回文数

//顺序栈的实际应用 
//判断是否为回文数:1221,12321
#include <stdio.h>
#define MaxSize 20
typedef struct{
	int data[MaxSize];
	int top;
}Stack;
//初始化
bool InitStack(Stack &s){
	s.top = -1;
	return true;
} 
//入栈
bool push(Stack &s,int e){
	if(s.top == MaxSize - 1){
		return false;
	}
	s.top += 1;//因为数组下标从0开始，而开始指针指向-1所以要+1 
	s.data[s.top] = e;
	return true; 
}
bool pop(Stack &s,int &e){
	if(s.top == -1){
		return false;
	}
	e = s.data[s.top];
	s.top -= 1;
	return true;
} 
int main(){
	Stack s;
	int sum;//回文数的个数
	int team[MaxSize];
	int i,e; 
	int temp = 0;
	if(InitStack(s)){
		printf("初始化成功\n");
		printf("请输入回文数的个数:");
		scanf("%d",&sum);
		printf("请输入:");
		for(i = 0;i < sum;i ++){
			scanf("%d",&team[i]);
		}
		
				for(i = 0;i < sum / 2;i ++){//一半的元素进栈 
					push(s,team[i]);//入栈 
				
				}
		if(sum % 2 == 0){
			i = 0;
			while(i < sum / 2){
				pop(s,e);
				if(e != team[sum / 2 + i]){
					temp = 1;
				}
				i ++;
			}
		}
		else{
			i = 0;
			
		
			while(i < sum / 2){
				pop(s,e);
				if(e != team[sum / 2 + i + 1]){
					temp = 1;
				}
				i ++;
			}
			
		}
	  if(temp == 1){
	  	printf("不是回文数");
	  }else{
	  	printf("是");
	  }
	
		
		
		
	}
	return 0;
}

栈的链式存储结构

对于链栈来说,不存在栈满的情况，除非内存已经没有可以使用的内存

带头结点

L1结点入栈
在这里插入图片描述
L2入栈
在这里插入图片描述
我们发现这个S结点并没有存放数据那就是头结点

#include <stdio.h>
#include <stdlib.h>
//带有头结点的链栈 
typedef struct StackNode{
	int data;
	struct StackNode *next;//我们会发现这个定义和单链表的定义是一样的 
}StackNode,*LinkStackPtr;
//初始化
bool InitStack(LinkStackPtr &s){
	
	s = (StackNode *)malloc(sizeof(StackNode));
	if(!s){
		return false;
	}
	s->next = NULL;//带有头结点的链栈 
	return true;
} 
//进栈
bool push(LinkStackPtr &s,int e){
	StackNode *L = NULL;
	L = (StackNode *)malloc(sizeof(StackNode));
	if(L == NULL){
		return false;
	}
	L->next=NULL;//将新入栈的结点的指针域设为空
	L->data = e;//将元素添加到申请的结点的数据域中
	L->next = s->next;//将新添加的栈元素放到栈顶那他的指针域就存放下一个结点 
	s->next =L; //将栈顶指针指向栈顶元素 
	return true;
	 
} 
//出栈
bool pop(LinkStackPtr &s,int &e){
	StackNode *p = NULL;
	if(s->next == NULL){
		return false;
	}
	p=s->next;//将s所指向的结点让p也指向他 
	e=p->data;
	s->next = p->next;
	free(p);
	return true;
} 

//打印栈元素
int StackPrint(LinkStackPtr s){
	StackNode *p = NULL;
	if(s->next == NULL){
		return 0;
	}

	p = s->next;
	while(p != NULL){
		printf("元素:%d\t",p->data);
		p=p->next;
	}
} 
int main(){
	LinkStackPtr s;
	int e;
	int i;
	if(InitStack(s)){
		printf("初始化成功\n");
		for(i = 0;i < 4;i ++){
				printf("请输入入栈元素:");
				scanf("%d",&e);
				if(push(s,e)){
			        printf("入栈成功\n");
		        }
		}
		for(i = 0;i < 4;i ++){
			pop(s,e);
			printf("出栈:%d\t",e);
			
		}	
		if(StackPrint(s) == 0){
			printf("链栈为空\n");
		}else{
			StackPrint(s);
		}
	
		
	}
	return 0;
}

不带头结点

#include <stdio.h>
#include <stdlib.h>
//不带头结点的链栈 
typedef struct StackNode{
	int data;
	struct StackNode *next;
}StackNode,*LinkStack;
//初始化
bool InitStack(LinkStack &s){
	s = NULL;
	return true;
} 
//入栈
bool push(LinkStack &s,int e){
	StackNode *L = NULL;
	L = (StackNode *)malloc(sizeof(StackNode));
	if(L == NULL){
		return false;
	}
	L->data = e;
	L->next = s;
	s = L;//栈顶指针指向栈顶元素
	return true;
	 
} 
//出栈
bool pop(LinkStack &s,int &e){
	if(s == NULL){
		return false;
	}
	StackNode *p = NULL;
	p = s;
	e = p->data;
	s = p->next;
	free(p);
	return true;
}
//打印栈中所有元素
int StackPrint(LinkStack s){
	if(s == NULL){
		return 0;
	}
	StackNode *p = NULL;
	p = s;
	while(p != NULL){
		printf("%d\t",p->data);
		p = p->next;
	}
} 
int main(){
	LinkStack s;
	int e;
	if(InitStack(s)){
		printf("初始化成功\n");
		printf("请输入要入栈的元素:\n");
		scanf("%d",&e);
		if(push(s,e)){
			printf("入栈成功\n");
		}
		if(pop(s,e)){
			printf("出栈元素:%d\t",e);
		}
		if(StackPrint(s)){
			StackPrint(s);
		}
	}
	return 0;
}

总结

链栈和顺序栈:
时间复杂度:都为O(1)
空间复杂度:顺序栈需要提前分配空间,而链栈就比较灵活了通过指针可以有效利用内存中的空间
使用:当栈长度不固定使用链栈，当栈长度固定使用顺序栈

【数据结构】-顺序栈(初始化栈顶指针为0）
RunningSnail的博客
07-23 5946
顺序栈-初始化栈顶指针为01.头文件及类型定义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）
RunningSnail的博客
07-22 5381
顺序栈-初始化栈顶指针为-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
顺序栈的实现
weixin_54042669的博客
07-23 96
#include"iostream" using namespace std; #define OK 1 #define ERROR 0 #define MAXSIZE 100 typedef struct { int *base; int *top; int stacksize; }SqStack; int InitStack(SqStack &s) { s.base = new int[MAXSIZE]; if (!s.base) exit(OVERFLOW); s.top =.
关于栈顶指针初值为-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.
顺序栈—栈顶指针的两种初始化
weixin_48334973的博客
07-16 3049
采用顺序存储的栈称之为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针指示当前栈顶元素的位置。 下面给出两种栈顶指针定义的方式，讨论两种方式中在出栈、入栈代码上的不同： 1、栈顶指针top初始化为0： 入栈： 出栈： 2、 初始化栈顶指针为-1： 入栈： 出栈： ...
数据结构——栈的详解
热门推荐
晴空๓
04-20 8万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
数据结构：栈
m0_72625526的博客
05-04 2001
栈(Stack)是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。栈顶(Top)线性表允许进行插入删除的那一端栈底(Bottom)固定的，不允许进行插入和删除的另一端。空栈不含任何元素。
栈结构概述
橘猫吃不胖的博客
03-01 3290
栈结构概述1 认识栈结构2 通过实例理解栈3 实现栈结构 1 认识栈结构 我们都知道数组是一种线性结构，并且可以在任意位置插入和删除数据。但是有时为了实现某些功能，我们必须对这种任意性加以限制。而栈和队列就是常见的受限的线性结构。 栈是一种受限的线性表，后进先出。其限制是仅允许在表的一端进行插入和删除操作，这一端被称为栈顶，另一端称为栈底。LIFO（last in first out）表示就是后进入的元素，第一个弹出栈空间。向一个栈插入新元素又称为进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新
profinet协议栈源码
05-16
标题"profinet协议栈源码"指的是这个项目是关于PROFINET通信协议的软件实现，其核心是协议栈的源代码。PROFINET是一种基于以太网技术的工业自动化网络标准，由德国西门子公司发起，广泛应用于制造业自动化领域。 ...
LwIP协议栈源码详解.pdf
05-03
"LwIP协议栈源码详解" LwIP协议栈是 lightweight TCP/IP 协议栈的实现，它是一种轻量级、开源的嵌入式系统网络协议栈，广泛应用于嵌入式系统、物联网、自动化控制等领域。LwIP 协议栈的设计目标是提供一个小巧、...
Linux 中的各种栈：进程栈 线程栈 内核栈 中断栈
05-06
在Linux系统中，栈可以分为进程栈、线程栈、内核栈以及中断栈。 首先，我们需要了解栈（Stack）的基本概念。栈是一种后进先出（LIFO, Last In First Out）的数据结构，它允许数据被存储和检索，但只允许在一段称为...
数据结构栈的实验报告.doc
07-11
实验报告的主题是关于数据结构中的顺序栈的基本操作，主要涵盖了栈的初始化、进栈、出栈等核心概念。顺序栈是一种特殊的线性表，它的特点是只允许在一端进行插入和删除操作，这一端称为栈顶。 1. **栈的类型定义**...
数据结构顺序栈验证实验报告.pdf
07-11
数据结构中的顺序栈是一种特殊的线性表，它具有后进先出（LIFO）的特点，即最后进入的元素最先离开。在本实验报告中，学生通过编写C语言代码来理解和验证顺序栈的操作特性。 首先，实验的目标是让学生掌握栈的顺序...
数据结构:已知LA、LB中的数据元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的数据元素仍按
qq_43728862的博客
03-05 8757
#include <stdio.h> #include <stdlib.h> #define MAX 10 #define ADD 10 #define OVER -2 #define ERROR -1 #define OK 1 typedef int ElemType; typedef struct SqList{ ElemType *elem; int lengt...
数据结构:树和二叉树
qq_43728862的博客
06-06 7729
树和二叉树 树的定义和基本语句 二叉树 遍历二叉树和线索二叉树 树和森林 霍夫曼树及其应用 树的定义和基本语句 树是n个结点的有限集 树的表示方法 基本术语 根:即根节点（没有前驱） 叶子结点:即终端节点(没有后继) 森林：是有n棵树的集合 树的深度：所用节点层数中的最大值 二叉树 基本特点: 节点的度小于等于2 子树有序 二叉树的性质 1,在二叉树的第i层上至多有2^(i - 1)个结点(除叶子结点外，其余子树的度都为2) 2,深度为k的二叉树至多有2^k - 1个结点(总共的节点数) 3,对于任何
数据结构:顺序线性表插入C语言实现
qq_43728862的博客
02-26 2137
数据结构:顺序表插入 /*初始条件:顺序线性表L已存在 操作结果:在L的第i个位置之前插入新的数据元素e，L的长度加一 */ Status ListInsert(SqList *L,int i,ElemType e) { int k; if(L ->length == MAXSIZE)//顺序表已经满了 { return ERROR; } if(i < 1 ||...
数据结构:新冠病毒检测
qq_43728862的博客
04-09 1808
检测是采用字符串的查找即KMP算法 KMP算法的核心是求next[]数组 例如 所以代码如下 #include <stdio.h> #include <stdlib.h> #include <string.h> #define NAME "病毒" #define PASS "12345" typedef unsigned char String[256]; i...
数据结构:顺序线性表删除:C语言实现
qq_43728862的博客
02-26 1767
数据结构: /*初始条件:顺序线性表L已存在 操作结果:删除L的第i个数据元素，并用e返回其值，L长度- 1 */ Status ListDele(SqList *L,int i,ElemType *e) { int k; if(L -> length == 0) { return ERROR; } if(i > L -> length || i < 1) ...
颠倒栈
最新发布
04-01
栈是后进先出（FILO）的结构，颠倒栈意味着将栈中的元素顺序完全反转，比如原来的栈顶元素变成栈底，栈底变成栈顶。 根据引用[4]提到的思路，最简单的方法是使用一个辅助栈。比如，原栈为栈1，先创建一个栈2。然后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值