详解顺序栈

已于 2023-10-22 10:54:36 修改
阅读量270 收藏
点赞数
文章标签： java 数据结构 开发语言
于 2023-10-21 10:26:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61792026/article/details/133958030
版权

一、定义

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

二、表现和实现

1.top、base 指针指向数组的下标，用 int 类型定义
2.top 始终指向栈顶元素的后一位
3.空栈: base==top;
4.栈满: top-base==stacksize;
5.上溢: 栈已满,又要压入元素(错误,使元素无法进入);
6.下溢: 栈已空,还要弹出元素(一般作为结束条件);

三、特点

顺序栈是用数组存储数据的，因此也称为数组栈。
顺序栈的栈底固定不变，设在数组的起始位置，而栈顶则随着数据的插入和删除操作而不断变化。
顺序栈遵循“后进先出”（LIFO）的原则，即最后插入的元素最先被删除，而最先插入的元素最后被删除。

四、 顺序栈的基本运算

1.初始化

/* 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.入栈

 
/* 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.出栈

/* 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.栈顶

/* 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.判断栈是否为空

/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}

6.判断栈是否满

/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}

7.销毁

/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

五、 应用

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

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 = 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 = op2 / op1;
			push(&S, x);
			break;

		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

六、完整代码

/*
	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;
}
#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(" 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:
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			getchar(); 
			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:
	    	    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(" 本程序为顺序表演示。。。\n");
			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);
}
 
 
/*后缀表达式计算*/
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 = 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 = op2 / op1;
			push(&S, x);
			break;
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}
/*
	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);

七、运行结果

八、总结 

顺序栈的应用非常广泛，例如在表达式求值、算术表达式计算以及编译器中都离不开后缀表达式，顺序栈遵循“后进先出”（LIFO）的原则，即最后插入的元素最先被删除，而最先插入的元素最后被删除。顺序栈是一种非常重要的数据结构，对于算法设计和程序实现都有很大的帮助

m0_61792026
关注
C严蔚敏数据结构-顺序栈
qq_41481924的博客
01-18 608
1）base为栈底指针，初始化完成后，栈底指针base始终指向栈底的位置，若base的值为NULL，则表示栈结构不存在。top为栈顶指针，其初值指向栈底。每当插入新的栈顶元素时，指针top+1；删除栈顶元素时，指针top-1.因此，栈空时，top和base的值相等，都指向栈底；栈非空时，top始终指向栈顶元素的上一个位置。 2）stacksize指示栈可使用的最大容量 顺序栈的初始化 ...
顺序栈基本操作（入栈和出栈）C语言详解
数据结构和算法教程（C语言版）
03-14 1万+
顺序栈，即用顺序表实现栈存储结构。通过前面的学习我们知道，使用栈存储结构操作数据元素必须遵守 "先进后出" 的原则，本节就 "如何使用顺序表模拟栈以及实现对栈中数据的基本操作（出栈和入栈）" 给大家做详细介绍。 如果你仔细观察顺序表（底层实现是数组）和栈结构就会发现，它们存储数据的方式高度相似，只不过栈对数据的存取过程有特殊的限制，而顺序表没有。 例如，我们先使用顺序表（a 数组）存储{1,2,...
顺序栈——栈的顺序表示和实现
02-26 1773
栈的基本操作代码： #include<cstdio> #include<cstdlib> #define SElemType int #define Status int #define STACK_INIT_SIZE 100 //初始空间分配量 #define STACKINCREMENT 10 //存储空间分配增量 using namespace std...
【数据结构】第3章 栈和队列 顺序栈
wwr's study notes
08-15 502
【顺序栈的初始化、判空、取栈顶元素、入栈、出栈】
栈
の 影
08-01 160
栈是一种先进后出的数据结构，FILO(first-in-last-out)。 1.实现方式 1.1 顺序栈 base指向栈底，top指向栈顶元素的下一个。 //const int MAXSIZE = xx; struct SeqStack{ Ele * base; Ele * top; int stacksize; }; 对于顺序栈，也可以动态增加...
栈的基本操作（小系统）（base，top）
qq_46896305的博客
05-12 1755
栈的基本操作 包含九个基本操作 如下： #include <stdio.h> #include<string.h> #include<stdlib.h> #include<sys/malloc.h> #define OK 1 #define ERROR 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int ElemType; typedef int Statu
数据结构——顺序栈详解
最新发布
weixin_51785373的博客
10-20 2076
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
数据结构《顺序栈》知识点详解+C语言完整代码-超详细
susuwhsbbs的博客
01-15 4959
顺序栈栈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语言实现：顺序栈与链栈操作详解
"数据结构课程涵盖了顺序栈和链栈的实现，主要使用C语言进行编程。顺序栈是基于一组连续存储单元实现的栈，而链栈则是通过链式存储结构来实现。这两种栈都支持常见栈操作，如初始化、入栈、出栈、取顶、查询栈长和...
数据结构-栈详解（类C语言版）
秃了也弱了
04-09 2115
栈的定义 概念 栈 (stack) 是限定仅在表尾进行插入或删除操作的线性表。 因此， 对栈来说， 表尾端有其特殊含义， 称为栈顶 (top), 相应地， 表头端称为栈底 (bottom)。 不含元素的空表称为空栈。 栈又称为后进先出 (Last In First Out, LIFO) 的线性表。 栈的抽象数据类型定义 ADT Stack { 数据对象： D = {ai | ai∈ElemSet , i = 1,2,...,n,n≥0 } 数据关系： ...
栈的顺序存储表示
C语言、数据结构、算法
11-28 275
/* c3-1.h 栈的顺序存储表示 */ #define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */ #define STACKINCREMENT 2 /* 存储空间分配增量 */ typedef struct SqStack { SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */ SEle...
lua函数栈的base和top会冲突吗？
HIHeASy
01-06 1079
lua虚拟机在运行指令的使用会使用诸如RA, RB, RC等宏来找变量的位置， 这三个宏分别以base为底，加上指令中的A，B, C操作数。 而我们平时用到的 void  (lua_pushnumber) (lua_State *L, lua_Number n); 这类函数是基于top的， 那么在push我们的数据时，会不会覆盖了一些正在使用的数据呢， base和top都指示栈上的位置，他们是如
base_堆和栈的区别
香橙的博客
02-27 621
堆（Heap）栈（Stack） 一个由c/C++编译的程序占用的内存分为以下几个部分 : 1、栈区（stack） —— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap） —— 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。 3、全局区（静态区） ——（sta
数据结构与算法丨栈
兔子王
10-03 1701
数据结构与算法之栈。
栈和队列的操作一——栈的顺序存储结构
m0_72619231的博客
03-31 2182
两个 SElemType 类型的指针，栈顶指针top，栈底指针base,栈的长度stacksize;}SqStack;
栈的top指针指向哪里_栈和队列
热门推荐
weixin_39893042的博客
12-03 1万+
栈： 后进先出（Last In First Out，LIFO）的线性序列，称为“栈”。栈也是一种线性表，只不过它是操作受限的线性表，只能在一端进出操作。进出的一端称为栈顶（top）,另一端称为栈底（base）。栈可以用顺序存储，也可以用链式存储，分别称为顺序栈和链栈。顺序栈： 顺序栈需要两个指针，base表示栈底指针（指向首地址或基地址），top表示栈顶指针。（top指针永远指向...
栈的详解（C/C++数据结构）
qq_54169998的博客
11-17 7428
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值