详解顺序栈

已于 2023-10-26 18:51:40 修改
阅读量170 收藏
点赞数
文章标签： 数据结构 算法
于 2023-10-20 13:56:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53454890/article/details/133944079
版权

一.定义

顺序栈（Sequential Stack）是一种基于数组的数据结构，用于实现栈（Stack）的操作。栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，顺序栈就是在数组的基础上实现的栈结构。

以下是顺序栈的主要定义：

  1. 数据结构：顺序栈是由一个一维数组和一个指示栈顶位置的整数构成的数据结构。

  2. 操作：顺序栈支持两主要操作：

    • 入栈（Push）：将元素压入栈顶。这是在数组的栈顶位置插入一个新元素。
    • 出栈（Pop）：将栈顶元素弹出。这是从栈顶位置移除元素。

  3. 特点：

    • 栈顶指针：通常用一个整数变量（例如，top）来表示栈顶的位置。栈顶指针指向栈顶元素的位置，初始时可以设为-1。
    • 队列大小：通常栈的大小是固定的，取决于数组的大小。一旦栈满了，就不能再进行入栈操作。
    • 空栈检测：通过栈顶指针的位置来检测栈是否为空。当栈顶指针为-1时，表示栈为空。
    • 溢出检测：通过栈顶指针的位置来检测栈是否已满。当栈顶指针等于数组的最大索引时，表示栈已满。

  4. 应用：顺序栈常用于需要实现后进先出操作的场景，如表达式求值、括号匹配、函数调用管理等。

二．特点

  1. 基于数组实现：顺序栈是基于数组的数据结构，栈中的元素存储在数组中，通过数组的索引来访问栈中的元素。

  2. 后进先出（LIFO）：栈是一种后进先出的数据结构，即最后入栈的元素最先出栈，类似于堆叠物品。

  3. 固定大小：顺序栈的大小通常是固定的，由数组的大小决定。一旦栈满了，无法再进行入栈操作。

  4. 栈顶指针：通常使用一个整数变量（如top）来表示栈顶的位置，该指针指向栈顶元素的位置。初始时，可以将栈顶指针设为-1。

  5. 空栈检测：通过栈顶指针的位置来检测栈是否为空。当栈顶指针等于-1时，表示栈为空。

  6. 溢出检测：通过栈顶指针的位置来检测栈是否已满。当栈顶指针等于数组的最大索引时，表示栈已满，无法再进行入栈操作。

  7. 常用于实现函数调用栈：顺序栈常用于实现函数调用栈，其中每次函数调用时，函数的局部变量和返回地址被入栈，函数返回时，这些数据被出栈，以实现函数的递归调用和返回。

  8. 常见应用：顺序栈在计算机科学中有广泛的应用，包括表达式求值、括号匹配、回文判定、历史记录的前进和后退功能等。

总之，顺序栈是一种简单而有效的数据结构，用于解决许多需要后进先出操作的问题，它的固定大小和栈顶指针是其主要特点，使其在很多场景下非常有用。

三.顺序栈的实现

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;
}

四.完整demo

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[])
{
	(void)argc;
	(void)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(" 9. 帮助\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:
            getchar();
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}
			break;
            case 4: {
			    DataType topElement;
			    int result = get_top(&S, &topElement);
			
			    if (result == 0) {
			        printf("栈顶元素为【%d】;\n", topElement);
			    } else {
			        printf("获取栈顶元素失败，错误代码：%d\n", result);
			    }
			    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:
                destroy(&S);
                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;
 
            case 9:
                printf("本程序由邵毅豪开发，如有bug欢迎交流");
		}
 
 
	}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<(int)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 = op1 * op2;
			push(&S, x);
			break;
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
	return 0;
}
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);
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;
}

五.运行效果截图

 六.小结

顺序栈（Sequential Stack）是栈（Stack）的一种实现方式，它是一种线性数据结构，遵循先进后出（FILO）或后进先出（LIFO）的原则。顺序栈使用数组来存储栈中的元素，提供了一组基本操作，包括初始化、入栈、出栈、取栈顶元素、检查栈是否为空、检查栈是否满、以及销毁栈。

以下是顺序栈的关键特点和操作：

  1. 初始化（init）： 在使用顺序栈之前，需要进行初始化，为数组分配内存，并设置栈顶指针等参数。初始化操作允许你指定栈的最大容量。

  2. 入栈（push）： 将元素压入栈顶。这是通过将元素添加到数组中的栈顶位置（栈顶指针上方）来实现的。栈顶指针会相应地增加。

  3. 出栈（pop）： 从栈顶移除元素。这是通过将栈顶指针下移一个位置来实现的。出栈操作通常返回被移除的元素的值。

  4. 取栈顶元素（get_top）： 获取栈顶元素的值，但不将其从栈中移除。这个操作只是读取栈顶元素的值。

  5. 栈是否为空（empty）： 检查栈是否为空。如果栈顶指针为-1，那么栈被认为是空的。

  6. 栈是否满（full）： 检查栈是否已满。如果栈顶指针等于栈的最大容量减1，那么栈被认为是满的。

  7. 销毁（destroy）： 释放分配给栈的内存。这是为了防止内存泄漏，通常在不再需要栈时调用。

顺序栈通常用于需要以后进先出的顺序处理数据的情况，例如在计算机科学和计算机工程中的各种应用中。它是一种基本的数据结构，用于管理数据的存储和检索，例如计算后缀表达式、内存管理和函数调用栈等。理解顺序栈是学习更高级数据结构和算法的基础。

weixin_53454890
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
栈的四则运算实现及详解
05-15
c语言数据结构栈的四则运算（带括号）的实现，里面有解释
数据结构 栈的操作实例详解
08-30
主要介绍了数据结构 顺序栈的定义、初始化、空栈判断、入栈、出栈操作的相关资料,需要的朋友可以参考下
栈详解 顺序栈 基本操作 C语言实现 数据结构
weixin_63666347的博客
05-14 1162
一、栈 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 1.2栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些，因为数组在尾上插入数据的代价比较小 顺序栈基本操作 #include<stdio.h> #include<stdlib.h> #incl..
栈详解（顺序栈和链栈）
o8699458的博客
08-08 1435
栈什么是栈？顺序栈链栈 什么是栈？ 栈是一种基本数据结构，因其拥有后进先出的特点（Last in First out），也就是LIFO，栈的一种常见用途就是用来判断一串字符中的括号是否有效。 括号的类型有{}、[]、()，“{[]}”像这样的就是有效的，而像"{[])"这样的就是无效的括号，这通常用于编译器的语法检查。 在内存的中使用也是一种栈，因函数调用会压栈，每调用一次压栈一次，当递归层次太深时，我们经常看到编译器报错：“Stack Overflow”,也就是栈溢出。 栈的主要操作有Push和Pop，入
顺序栈的详解
qq_54938554的博客
10-19 1389
栈是一种特殊的数据结构，它的特点是后进先出（Last In First Out，LIFO）。栈是一种线性结构，它可以用来存储一组具有相同类型的数据元素。栈的基本操作包括压入（push）和弹出（pop），其中压入操作将数据元素添加到栈的顶部，弹出操作将栈顶的数据元素移除并返回。/* 堆空间 */int top;/* 栈顶指针 */}SeqStack;/* 1. 初始化 *//* 2. 进（入）栈 *//* 3. 出栈 *//* 4. 取栈顶元素 *//* 5. 栈为空？*/
数据结构——顺序栈详解
weixin_51785373的博客
10-20 1673
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
栈的原理详解及其python实现
01-20
文章目录一、原理介绍1、基本介绍及特点二、python实现（一）、顺序栈的实现1、Python实现顺序栈2、代码测试（二）、链栈1、Python实现链栈2、测试三、注意事项（持续补充中…） 一、原理介绍 1、基本介绍及特点 栈...
javascript编程实现栈的方法详解【经典数据结构】
12-11
这里讲一下顺序栈，设置指针top指示栈顶元素在顺序栈中的位置。通常的做法就是以top=0表示空栈。base为栈底指针，top为栈顶指针。 如果base为null，则表示栈结构不存在，如果top=base则表示空栈。每当插入一个新的...
【排序算法】计数排序（CountSort）
SWsunlight的博客
06-08 601
计数排序
排序-快速排序
18602
06-15 119
快速排序（Quick Sort）是一种高效的排序算法，由英国计算机科学家霍尔（C. A. R. Hoare）在1960年提出。它的基本思想是：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
数据结构之LinkedList与链表（上）
我要学编程的博客
06-12 1081
手动实现单链表的源码 手动实现双链表的源码 分析LinkedList 的源码 LinkedList的使用：常用方法 ArrayList 和 LinkedList的区别
C语言刷题（函数）
2303_82176667的博客
06-09 709
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
数据结构分类总结[多达80种,offer收割机]
爱学习_萌萌哒
06-14 309
线性结构： 数组（Array） 链表（Linked List）：包括单链表、双向链表和循环链表 栈（Stack）：后进先出（LIFO）的数据结构 队列（Queue）：先进先出（FIFO）的数据结构 双端队列（Deque）：允许在两端进行插入和删除操作 非线性结构： 树（Tree）：包括二叉树、平衡二叉树、二叉搜索树、AVL树、红黑树等 图（Graph）：包括有向图、无向图、加权图、无权图等 散列结构： 哈希表（Hash Table）：通过哈希函数将键映射到表中的位置
数据结构——队列(Queue)详解
Yuan_o_的博客
06-14 126
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)的性质入队列：进行插入操作的一端称为队尾(Tail/Rear)出队列：进行删除操作的一端称为队头(Head/Front)
数据结构02 队列及其应用【C++实现】
bigbigli
06-14 265
队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，前端一般叫做队头，后端叫队尾。队列就像学校做操站队一样，来的人一个一个往后站，走的时候从前往后一个一个走。
数组的最大美丽值
__1_1__的博客
06-15 288
2.对于所有nums[i]-k < 0 的部分都可以用0代为表示，即[-3, a], [-6, b], [-9, c]与[0, a], [0, b], [0, c]的最大美丽值是一样的，因为nums[i]>=0, 区间有小于0的部分时，区间必然包含整数 0。题目可以理解为nums[i]是一个范围为[ nums[i] - k, nums[i] + k]的区间，然后要求所有区间叠加后重复最多的元素个数是多少。将 nums[i] 替换为范围 [nums[i] - k, nums[i] + k] 内的任一整数。
数据结构篇：旋转操作在AVL树中的实现过程
weixin_41489908的博客
06-15 204
本文详细介绍了AVL树中的旋转操作及其实现过程，包括右旋、左旋、左右旋和右左旋。通过多个代码案例，我们展示了这些旋转操作的应用和效果。在实际开发中，AVL树通过旋转操作保持平衡，从而保证二叉搜索树的高效性能。希望这些示例和注意事项能帮助你更好地理解和应用AVL树中的旋转操作。
数据结构-3、栈、队列和数组
最新发布
qq_66013948的博客
06-15 543
​ 队列，也是一种操作受限的线性表，只允许在表的一端进行插入，而表的另一端进行删除。向队列中插入元素成为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队时一致的，最早排队的也是最早离队的，其操作的特性是先进先出（FIFO），如下图：​ 对头。允许删除的一端，又称队首。​ 队尾。允许插入的一端。​ 空队列。不含任何元素的空表。
c++ linked stack详解
03-28
Linked stack是一种基于链表实现的栈数据结构，它和顺序栈不同，顺序栈是基于数组实现的，Linked stack是基于链表实现的。这也是它和顺序栈的最大区别。 Linked stack的实现主要依靠链表的基本操作，包括插入、删除和查询等。与顺序栈相比，Linked stack的内存空间使用更加灵活，因为链表的内存分配是动态的，可以根据需要分配和释放内存空间。 Linked stack的基本操作包括入栈和出栈。入栈操作即将一个元素压入栈中，出栈操作即将栈顶元素弹出。由于Linked stack的实现依靠链表，所以入栈和出栈操作都可以在链表的头部进行，这样可以更加方便和高效地实现栈的操作。 Linked stack还有一些其他的操作，例如获取栈顶元素、判断栈是否为空和清空栈等。这些操作都可以通过链表的基本操作来实现，具体实现方法和顺序栈相比略有不同，但是原理和基本思路是相同的。 总之，Linked stack是一种基于链表实现的栈数据结构，它的实现依靠链表的基本操作，包括插入、删除和查询等。与顺序栈相比，Linked stack的内存空间使用更加灵活，因为链表的内存分配是动态的，可以根据需要分配和释放内存空间。Linked stack的基本操作包括入栈和出栈，以及获取栈顶元素、判断栈是否为空和清空栈等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值