详解顺序栈

于 2023-10-23 16:05:51 发布
阅读量134 收藏
点赞数
文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53095050/article/details/133980509
版权

一、顺序栈的定义

顺序栈是指利用顺序存储结构实现的栈。栈的顺序存储的实现就是顺序栈，利用一组地址连续的存储单元存放自栈底到栈顶的数据元素。由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。

二、顺序栈的特点

顺序栈是限定仅在表尾插入和删除操作的线性表。允许插入和删除的一端称为栈顶，另一端称为栈底。不含任何数据元素的栈称为空栈。顺序栈用数组存储数据，整型变量指向栈顶。顺序栈的插入操作称入栈，顺序栈的删除操作称为出栈。

操作只能在栈顶进行，因此可以按照先进后出的原则进行元素的操作。

顺序栈与链栈类似，但顺序栈的插入和删除操作只能在栈顶进行，而链栈可以跨层存储元素。

三、顺序栈的优缺点

优点：
空间利用率高：顺序栈采用连续的存储空间，可以充分利用内存空间。
操作方便：顺序栈的操作都是在栈顶进行的，可以方便地实现入栈和出栈操作。
缺点：
插入和删除操作需要移动元素：顺序栈在进行入栈和出栈操作时，需要移动栈中元素，因此时间复杂度为O(n)。
不适合多线程并发访问：顺序栈采用连续的存储空间，如果多个线程同时对栈进行操作，可能会发生数据冲突或数据不一致的问题。

四、顺序栈的实现

1、顺序栈的定义
typedef int DataType;
 
 
typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;
2、顺序栈的初始化 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}
3、入栈
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}
4、出栈 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
}
5、取栈顶元素
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;
}
6、判断栈是否为空
/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}
7、判断栈是否满
/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}
8、栈的销毁
* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

9、栈的应用

（1）十进制转二进制

/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;
 
	/*初始化栈*/
	init(&S,32);
 
	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}
 
	/*销毁栈*/
	destroy(&S);
	return 0;
}

（2）后缀表达式计算

/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;
 
	char exp[20]; /*后缀表达式*/
 
	init(&S, 10);
 
	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);
 
	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
	    case '0':
	    case '1':
	    case '2':
	    case '3':
	    case '4':
	    case '5':
	    case '6':
	    case '7':
	    case '8':
	    case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;
		case'-':
			pop(&S,&op1);
			pop(&S,&op2);
			x=op2-op1;
			push(&S,x);
			break;
		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
			break;
		case '/':
			pop(&S,&op1);
			pop(&S,&op2);
			x=op2/op1;
			push(&S,x);
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

五、完整代码（Demo）

1、main.c

#include <stdio.h>
#include <string.h>
 
#include "seqstack.h"
 
/*十进制转换为二进制*/
int d_to_b(int d);
 
/*后缀表达式计算*/
int expression();
 
int main(int argc, char* argv[])
{
	SeqStack S;
 
	int cmd;
	int d;
 
	DataType x;
	int maxsize;
	char yn;
 
	
	do
	{
		printf("---------顺序栈演示程序-----------\n");
		printf(" 1. 初始化\n");
		printf(" 2. 入栈\n");
		printf(" 3. 出栈\n");
		printf(" 4. 取栈顶元素\n");
		printf(" 5. 栈是否空？\n");
		printf(" 6. 栈是否满？\n");
		printf(" 7. 销毁栈\n");
		printf(" 8. 栈的应用\n");
		printf("请选择（0~9,0退出)：");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			printf("请输入栈的最大存储空间(MaxSize)：");
			scanf("%d", &maxsize);
			if(!init(&S, maxsize))
			{
				printf("栈已初始化！\n");
			}
			break;
		case 2:
			printf("请输入入栈元素：x=");
			scanf("%d", &x);
			if(!push(&S, x))
			{
				printf("元素【%d】已入栈！\n", x);
 
			}
			break;
		case 3:
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			flushall();
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}
 
			break;
		case 4:
			if(!get_top(&S,&x))
			{
			printf("栈顶元素为【%d】\n",x);
			}
			break;
		case 5:
			if(empty(&S)){
				printf("栈为空！\n");
			}
			else{
				printf("栈不为空！\n");
			}
			break;
		case 6:
			if(full(&S)){
				printf("栈已满！\n");
			}
			else{
				printf("栈未满\n");
			}
			break;
		case 7:
			printf("请问你确定要销毁栈吗（销毁后数据不可恢复,y|n,n）");
			flushall();
			scanf("%c", &yn);
			if(yn=='y'||yn=='Y')
			{
				if(!destroy(&S))
				{
					printf("栈已经销毁!\n");
				}
			}
			break;
		 case 9:
            printf("本程序为顺序栈的演示程序，由吴才猛设计开发，程序完成了入栈、出栈、取栈顶、判断栈是否为空、销毁栈等功能!\n");
            break;
		case 8:
			do
			{
				printf("----------8.栈的应用------------\n");
				printf(" 1. 十进制转换为二进制\n");
				printf(" 2. 后缀表达式计算\n");			
				printf(" 0. 返回\n");
				printf("请选择：");
				scanf("%d", &cmd);
 
				if(cmd == 1)
				{
					printf("请输入一个十进制数：");
					scanf("%d", &d);
					printf("二进制为：");
					d_to_b(d);
					printf("\n");
				}
 
				if(cmd == 2)
				{
					expression();
				}
			}while(cmd!=0);
			cmd = -1;
			break;
		}
 
	}while(cmd!=0);
 
	return 0;
}
 
 
 
/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;
 
	/*初始化栈*/
	init(&S,32);
 
	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}
 
	/*销毁栈*/
	destroy(&S);
	return 0;
}
 
 
/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;
 
	char exp[20]; /*后缀表达式*/
 
	init(&S, 10);
 
	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);
 
	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;
		case'-':
			pop(&S,&op1);
			pop(&S,&op2);
			x=op2-op1;
			push(&S,x);
			break;
		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
			break;
		case '/':
			pop(&S,&op1);
			pop(&S,&op2);
			x=op2/op1;
			push(&S,x);
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

2、 seqstack.c

/*
	seqstack.c
*/
#include <stdio.h>
#include <malloc.h>
#include "seqstack.h"
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}
 
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
}
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;
}
 
/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}
 
/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}
 
 
/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

3、seqstack.h

/*
	seqstack.h
	顺序栈
*/
 
typedef int DataType;
 
 
typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x);
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x);
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x);
 
/* 5. 栈为空？*/
int empty(SeqStack *S);
 
/* 6. 栈满？*/
int full(SeqStack *S);
 
/* 7. 销毁*/
int destroy(SeqStack *S);

 4、运行结果

六、小结

顺序栈在插入元素时，遵循先进后出（FILO）的原则，即最先插入的元素最后出栈。在删除元素时，也只允许从栈顶进行删除，并且遵循后进先出（LIFO）的原则，即最后插入的元素最先出栈。顺序栈的存储通常使用数组实现，因为这种方式可以利用数组的连续存储空间，快速定位到栈顶和栈底元素。同时，为了方便操作，通常会设置一个栈顶指针，指向栈顶元素在数组中的位置。

七、参考文献

1.季老师的代码

2.csnd博客

3.百度百科

4、同学帮助指导

qq_53095050
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
顺序栈 C++
05-09
顺序栈 C++ 实现详解 顺序栈是计算机科学中的一种基本数据结构，它是一种先进先出（First-In-First-Out，FIFO）的数据结构。下面我们将详细介绍顺序栈的 C++ 实现。 顺序栈的定义 顺序栈（Sequential Stack）是一...
栈的四则运算实现及详解
05-15
c语言数据结构栈的四则运算（带括号）的实现，里面有解释
数据结构——顺序栈
2301_77179941的博客
05-08 6910
栈（stack）又名堆栈，它是一种运算受限的线性表，要严格遵循先进后出的原理。
顺序栈的基本操作（超详细）
热门推荐
m0_53679998的博客
06-08 3万+
本文是在b站上学完王卓老师之后写的，各种操作我都觉得都十分的详细。如果代码或者描述有不对的地方，欢迎大家指正。
数据结构-顺序栈详解（C语言）
m0_55698213的博客
10-20 1824
本文主要讲述顺序栈基本定义和特点以及顺序栈的C语言代码实现与顺序栈的实际应用。以上就是顺序栈的基本介绍，本文仅仅简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出（FILO）的原则，即在栈顶添加和删除元素。顺序栈在计算机科学中经常使用，因为它允许我们在高频率的情况下进行添加和删除操作。
(全网最细）顺序栈详解 ＋实例解析
qq_45288176的博客
05-27 3483
目录 一：栈的介绍 1：什么是栈（Stack）？ 2：栈的特点 3：栈的相关概念 1：基本概念 2：基本操作和图示(如图为顺序栈实例) 4：栈的应用 三：栈的表示和操作实现 1：栈的抽象数据结构类型的定义 2：主要函数介绍 3.1顺序栈的表示和操作 1：了解顺序栈 2：特殊标志：栈空和栈满 3：栈的数据类型定义和操作 一：栈的介绍 1：什么是栈（Stack）？ 栈是一种常用的、重要的数据结构栈是一种限定插入和删除只能在表的 "端点”进行的线性表，此端点就在队.
栈结构之顺序栈详解（C语言版）
qq_44075108的博客
10-24 1万+
本文对栈结构的顺序栈进行详解并使用C语言对顺序栈进行实现，文章的主要内容包括顺序栈的定义、顺序栈的结构以及顺序栈的常用操作
LwIP协议栈源码详解_LwIP_协议栈详解_
09-29
**LwIP协议栈源码详解** LwIP（Lightweight TCP/IP）是一个开源的、轻量级的网络协议栈，适用于嵌入式系统。它由瑞典Chalmers大学的Adiscon公司开发，旨在为资源有限的微控制器提供TCP/IP功能。LwIP在设计时考虑了...
LwIP协议栈的设计与实现-中文 与 LwIP协议栈源码详解
最新发布
03-20
LwIP协议栈源码详解.pdf 和 LwIP协议栈的设计与实现_中文译稿.pdf 这两个文档很可能是深入分析LwIP源代码和设计原理的教程。它们可能涵盖了以下内容： 1. LwIP的架构和工作流程：详细解释各个模块的功能和交互方式...
栈和队列详解
06-17
"栈和队列详解" 栈和队列是数据结构中两个基本的数据结构概念，本文将详细介绍栈和队列的定义、原理、操作和应用。 栈的定义和原理 栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，栈中的元素按照加入...
顺序栈的讲解
m0_56992713的博客
10-24 9207
堆栈（简称栈）是插入和删除操作都在表的同一端进行的线性表。运行插入和删除元素的一端称为栈顶（top），另一端称为栈底（bottom）。如果堆栈中没有元素，则为空栈。栈是一个后进后出的结构（Last In First Out），简称为LIFO结构。 有几点需要注意： 1.栈本质上还是线性表，只是这个线性表增加了新的限定规则，只能在一端进行插入和删除。 2.栈和线性表一样，也有顺序存储（顺序栈）和链式存储（链式栈）两种结构。 3.栈的插入叫进栈，栈的删除叫出栈 目录顺序栈初始化出栈入栈判断栈空判断栈满取栈顶.
栈详解（顺序栈和链栈）
o8699458的博客
08-08 1446
栈什么是栈？顺序栈链栈 什么是栈？ 栈是一种基本数据结构，因其拥有后进先出的特点（Last in First out），也就是LIFO，栈的一种常见用途就是用来判断一串字符中的括号是否有效。 括号的类型有{}、[]、()，“{[]}”像这样的就是有效的，而像"{[])"这样的就是无效的括号，这通常用于编译器的语法检查。 在内存的中使用也是一种栈，因函数调用会压栈，每调用一次压栈一次，当递归层次太深时，我们经常看到编译器报错：“Stack Overflow”,也就是栈溢出。 栈的主要操作有Push和Pop，入
数据结构-顺序栈
2301_79870182的博客
10-19 258
在了解顺序站之前先了解什么是栈栈的概念：1、栈：一种只允许在一端进行插入或删除的线性表2、栈顶：线性表允许进行插入删除的那一端3、栈底：固定的，不允许进行插入和删除的那一端4、空栈：不含任何元素的空表栈了解完了我们在了解顺序栈顺序栈的定义顺序栈是栈的顺序实现。顺序栈是指利用顺序存储结构实现的栈。采用地址连续的存储空间（数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；
数据结构——栈（顺序栈）
qq_39628738的博客
03-11 3479
栈的概念：只能在表尾进行插入（入栈）和删除（出栈）的数据结构（受到限制的线性表）。 表尾比较特殊，我们一般把这个表尾叫做栈顶，另一端栈底。没有数据节点，则叫做空栈 特点：先进后出（FILO）a1最先进栈，a1最后出栈。 为了更好的理解，可以想象生活中的例子：子弹弹夹 直接给出栈的结构体定义：（结构体中需要三个成员） #define INIT_SIZE 10 typedef int ELEM_TYPE; typedef struct Stack { ELEM_TYPE* base;//一个
顺序栈（栈的顺序储存结构）
q322359的博客
09-13 1187
顺序栈（栈的顺序储存结构）
数据结构——顺序栈详解
weixin_51785373的博客
10-20 1823
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
C语言数据结构之顺序栈
m0_58303983的博客
10-21 657
顺序栈是栈的顺序实现，它利用顺序存储结构，即采用地址连续的存储空间（数组）依次存储栈中数据元素。由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处。栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。您的辛勤付出和无私奉献，让我感到非常敬佩和感激。我将永远铭记您的教诲，不断努力学习，成为一个对社会有用的人。不适用于大量数据的排序。
数据结构全部内容【图文总结】
12-31
"数据结构全部内容的图文总结，包括栈的概念、存储结构、运算规则以及顺序栈的实现，如初始化、清空、销毁、入栈和出栈操作的详细描述。" 在计算机科学中，数据结构是组织、管理和存储数据的重要方式，它影响着程序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值