详解顺序栈

已于 2023-10-24 01:00:22 修改
阅读量158 收藏
点赞数
文章标签： 数据结构 1024程序员节
于 2023-10-23 18:57:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H6001/article/details/133996241
版权

一，定义

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

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

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

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

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

栈顶指针：通常用一个整数变量（例如，top）来表示栈顶的位置。栈顶指针指向栈顶元素的位置，初始时可以设为-1。
队列大小：通常栈的大小是固定的，取决于数组的大小。一旦栈满了，就不能再进行入栈操作。
空栈检测：通过栈顶指针的位置来检测栈是否为空。当栈顶指针为-1时，表示栈为空。
溢出检测：通过栈顶指针的位置来检测栈是否已满。当栈顶指针等于数组的最大索引时，表示栈已满。
4.应用：顺序栈常用于需要实现后进先出操作的场景，如表达式求值、括号匹配、函数调用管理等。

二，特点

顺序栈（Sequential Stack）是一种基于数组的栈数据结构，具有以下特点：

  1. 固定容量：顺序栈的容量是固定的，由预定义的 MAX_STACK_SIZE 决定。一旦达到容量上限，栈就被认为是满的，无法再容纳更多元素。

  2. 先进后出（LIFO）：顺序栈遵循先进后出的原则，即最后入栈的元素最先出栈，栈顶元素是最后一个入栈的元素。

  3. 高效的操作：由于使用数组来实现，顺序栈的入栈（push）和出栈（pop）操作非常高效，通常具有常数时间复杂度。

  4. 有界性：由于容量是固定的，顺序栈的大小受到限制。当栈满时，无法再执行入栈操作。

  5. 需要合理的容量估计：要确保 MAX_STACK_SIZE 足够大以容纳可能的最大栈大小，否则可能会导致栈溢出。

  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("本程序由李英豪开发。");
		}
 
 
	}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）是一种基于数组实现的栈数据结构，具有以下要点和小结：

  1. 定义和特点：

    • 顺序栈由一个固定大小的数组和一个指向栈顶的指针组成。
    • 栈是一种后进先出（LIFO）的数据结构，栈顶元素是最后一个入栈的元素。

  2. 基本操作：

    • 顺序栈的基本操作包括初始化、入栈、出栈、获取栈顶元素、判空、判满等。
    • 入栈操作将元素添加到栈顶，出栈操作从栈顶移除元素。

  3. 容量限制：

    • 顺序栈具有固定的容量，由 MAX_STACK_SIZE 定义，一旦达到容量上限，栈被认为是满的，无法再容纳更多元素。

  4. 高效性：

    • 顺序栈的入栈和出栈操作通常具有常数时间复杂度，使其在许多应用中非常高效。

  5. 适用场景：

    • 适用于解决需要使用栈的问题，如逆序输出、简单表达式求值、括号匹配等。
    • 不适用于大规模动态数据集，因为容量固定且有界。

  6. 容量估计：

    • 需要合理估计容量，确保 MAX_STACK_SIZE 足够大以容纳可能的最大栈大小，否则可能导致栈溢出。

  7. 简单实现：

    • 顺序栈的实现相对简单，使用数组和一个指向栈顶的指针即可。
    • 适合用于需要高效栈操作的问题，但需要预估容量并合理选择数据结构以满足需求。

总之，顺序栈是一种高效的、固定容量的栈数据结构，适用于多种问题，尤其是需要使用栈解决的问题。它的简单实现和高效性使其成为许多算法和数据结构的重要组成部分。

H6001
关注
顺序栈基本操作（入栈和出栈）C语言详解
数据结构和算法教程（C语言版）
03-14 1万+
顺序栈，即用顺序表实现栈存储结构。通过前面的学习我们知道，使用栈存储结构操作数据元素必须遵守 "先进后出" 的原则，本节就 "如何使用顺序表模拟栈以及实现对栈中数据的基本操作（出栈和入栈）" 给大家做详细介绍。 如果你仔细观察顺序表（底层实现是数组）和栈结构就会发现，它们存储数据的方式高度相似，只不过栈对数据的存取过程有特殊的限制，而顺序表没有。 例如，我们先使用顺序表（a 数组）存储{1,2,...
数据结构：栈
qq_45868793的博客
04-11 220
栈（stack）：是限定仅在表尾（栈顶）进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为 栈顶（top），另一端称为 栈底（bottom），不含任何任何数据元素的栈称为 空栈。栈又称为 后进先出（Last In First Out） 的线性表，简称 LIFO 结构。 栈 是线性表的特例，其具备先进后出 FILO 特性。可以使用线性表的顺序存储结构（即数组）实现栈，将之称之为 顺序栈；可...
栈详解 顺序栈 基本操作 C语言实现 数据结构
weixin_63666347的博客
05-14 1213
一、栈 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 1.2栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些，因为数组在尾上插入数据的代价比较小 顺序栈基本操作 #include<stdio.h> #include<stdlib.h> #incl..
顺序栈
GUOSJIA的博客
10-16 613
顺序栈的操作 一、实验目的 掌握栈的顺序存储结构 验证顺序栈的基本操作 验证栈的特性 二、实验步骤 在工程中新建一个头文件SeqStack.h，gai 头文件包括顺序栈类SeqStack的定义 #ifndef SeqStack_H #define SeqStack_H const int StackSize = 10; template class SeqStack { public
数据结构——顺序栈详解
weixin_51785373的博客
10-20 1977
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
数据结构《顺序栈》知识点详解+C语言完整代码-超详细
susuwhsbbs的博客
01-15 4931
顺序栈栈1. 定义2. 逻辑结构3. 存储结构4. 运算规则5. 实现方式实现1. 顺序栈的表示2. 结构体3.初始化4.入栈5.出栈6. 去栈顶元素7.求长8.打印9.全部代码10.运行图栈的应用举例1.数制转换2.括号匹配的检验3.行编辑程序问题4.迷宫求解5.表达式求值6.实现递归 栈 1. 定义 栈：只能在表的一端（栈顶）进行插入和删除运算的线性表。 2. 逻辑结构 与线性表相同，仍为一对一关系。 3. 存储结构 用顺序栈或链栈存储均可，但以顺序栈更常见。 4. 运算规则 只能在栈顶运算，且访问结点
顺序栈定义
10-13
### 顺序栈定义与实现详解 在数据结构与算法的学习中，栈是一种常见的线性数据结构，具有后进先出（LIFO）的特点。本文将深入解析“顺序栈”的概念、实现原理及其代码示例，旨在帮助读者理解并掌握顺序栈的内部机制...
顺序栈 C++
05-09
顺序栈 C++ 实现详解 顺序栈是计算机科学中的一种基本数据结构，它是一种先进先出（First-In-First-Out，FIFO）的数据结构。下面我们将详细介绍顺序栈的 C++ 实现。 顺序栈的定义 顺序栈（Sequential Stack）是一...
【数据结构】排序算法系列——希尔排序（附源码+图解）
Skrrapper的博客
09-07 1055
希尔排序实际上是个相当复杂的排序算法，这主要是跟它的步长序列gap到底该如何取、后续应该减小有关。时，数组已经接近有序的了，就整体而言，最后一次整体的插入排序就可以大大提高效率——我们从插入排序的时间复杂度分析也可以看出，可以看到每次减小gap的规律是将原先的gap/2，但事实上这只是其中一种处理方法，并不说明这是最优解。，使得平均情况下的时间复杂度能够在O(n^1.3)左右，而不好的选择则可能导致接近最坏情况的性能。中，我们会将整体数据一分为多份，进行散布式的插入排序，这时候每一个子序列之间的间隙就是。
【数据结构】基本概念和术语
Sakura_ding的博客
09-09 931
是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部的使用。抽象数据类型和数据类型实质上是一个概念。“抽象”的意义在于数据类型的数学抽象特性。抽象数据类型的定义由一个值域和定义在该值域上的一组操作组成。若按其值的不同特性，可细分为下列三种类型：原子类型 (atomic data type)属原子类型的变量的值是不可分解的。
C语言代码练习(第十八天)
2201_75306399的博客
09-09 1380
C语言代码练习
数据结构 栈 队列
qq_69971969的博客
09-06 654
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
Redis常见的数据结构
weixin_61669379的博客
09-09 1068
Redis底层的数据结构是Redis高效存储和操作数据的基础,Redis提供了五种基本的数据类型，每种类型在底层都有对应的数据结构来实现。这五种数据类型分别是：字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。
数据结构————栈、队列
qq_63843346的博客
09-06 847
在使用数组实现的队列中，如果队列的尾部已经到达数组的末尾，但数组的前部仍有空闲空间，此时队列将无法继续入队，产生假溢出。：特别是在使用数组实现的队列中，如果队列的长度远小于数组的长度，那么数组的大部分空间将被浪费。：虽然队列的遍历通常比栈更简单（因为不需要额外的空间来保存遍历过程中的元素），但在某些情况下（如需要频繁遍历队列），队列的遍历效率可能不是最优的。即最早插入队列的元素将会是第一个被移除的。：栈的遍历通常需要额外的空间来保存遍历过程中的元素，因为栈的后进先出特性使得遍历过程与元素的自然顺序相反。
数据结构2 ：双向链表和内核链表
qq_65425321的博客
09-06 571
1.双向链表是一种链表数据结构，其中每个节点包含三个部分：一个数据域（存储节点的数据）、一个前驱指针（指向列表中的前一个节点）和一个后继指针（指向列表中的下一个节点）。2. 方便插入和删除：在双向链表中插入或删除一个节点只需要修改相邻节点的前后指针，而不需要遍历整个链表来查找前驱或后继节点。2. 内存管理：内核链表的节点需要从内核的内存池中分配和回收，因此需要考虑内存碎片和内存使用效率等问题。稍微复杂的操作：相对于单向链表，双向链表的操作逻辑稍微复杂一些，需要同时更新前后指针。双向链表的删除和销毁。
数据结构第二周做题总结_顺序表
最新发布
2301_79837864的博客
09-09 868
用C++语言和类实现顺序表属性包括：数组、实际长度、最大长度（设定为1000）操作包括：创建、插入、删除、查找类定义参考。
浙大数据结构：02-线性结构3 Reversing Linked List
qq_74924951的博客
09-06 487
C++实现。我使用了C++的STL库，使得代码量大幅减少。
C语言实现：顺序栈与链栈操作详解
"数据结构课程涵盖了顺序栈和链栈的实现，主要使用C语言进行编程。顺序栈是基于一组连续存储单元实现的栈，而链栈则是通过链式存储结构来实现。这两种栈都支持常见栈操作，如初始化、入栈、出栈、取顶、查询栈长和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值