详解顺序栈

已于 2023-10-22 22:37:34 修改
阅读量45 收藏
点赞数
文章标签： 数据结构
于 2023-10-22 22:34:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65087192/article/details/133977997
版权

栈的定义

栈是一种数据结构，它按照先进后出（Last In First Out，LIFO）的原则存储和访问数据。栈可以看作是一种特殊的线性表，只能在表的一端（称为栈顶）进行插入和删除操作。

栈的定义包括以下几个重要特点：

  1. 栈的插入操作称为入栈（Push），将数据元素放入栈顶。
  2. 栈的删除操作称为出栈（Pop），将栈顶的数据元素移除。
  3. 栈的访问限制只能在栈顶进行，即只能访问最后一个入栈的元素。
  4. 栈的大小是动态变化的，可以根据需要进行扩容或缩容。
  5. 栈可以使用数组或链表来实现。

栈的操作

1.初始化栈

2.入栈

3.出栈

4.取栈顶元素

5.判满

6.判空

7.销毁

顺序栈的实现

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

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

运行结果

栈的应用

十进制转二进制

/*十进制转换为二进制*/
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 '-':
			/* 出2个 */
			pop(&S, &op1);
			pop(&S, &op2);
			x = op2 - op1;
			push(&S, x);
			break;

		case '/':
			/* 出2个 */
			pop(&S, &op1);
			pop(&S, &op2);
			if (op1 == 0)
			{
				printf("错误：除数为0\n");
				destroy(&S);
				return 0;
			}
			x = op2 / op1;
			push(&S, x);
			break;



		}

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

 运行结果

完整Demo

mian.c

#define _CRT_SECURE_NO_WARNINGS 1
#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(" 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~8,0退出)：");
		scanf("%d", &cmd);
		switch (cmd)
		{
		case 1:
			printf("请输入栈的最大存储空间(MaxSize)：");
			scanf("%d", &maxsize);
			if (!init(&S, maxsize))
			{
				printf("栈已初始化！\n\n");
			}
			break;
		case 2:
			printf("请输入入栈元素：x=");
			scanf("%d", &x);
			if (!push(&S, x))
			{
				printf("元素【%d】已入栈！\n\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\n", x);
				}
			}
			break;
		case 4:
			DataType topElement;
			int result = get_top(&S, &topElement);
			
			if (result == 0) {
				printf("栈顶元素为【%d】;\n", topElement);
			}
			else {
				printf("获取栈顶元素失败!\n\n", result);
			}
			break;

		case 5:
			if (empty(&S)) {
				printf("栈为空！\n\n");
			}
			else {
				printf("栈不为空！\n\n");
			}
			break;

		case 6:
			if (full(&S)) {
				printf("栈已满！\n\n");
			}
			else {
				printf("栈未满！\n\n");
			}
			break;

		case 7:
			destroy(&S);
			printf("栈已销毁！\n\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);
}


/*后缀表达式计算*/
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 '-':
			/* 出2个 */
			pop(&S, &op1);
			pop(&S, &op2);
			x = op2 - op1;
			push(&S, x);
			break;

		case '/':
			/* 出2个 */
			pop(&S, &op1);
			pop(&S, &op2);
			if (op1 == 0)
			{
				printf("错误：除数为0\n");
				destroy(&S);
				return 0;
			}
			x = op2 / op1;
			push(&S, x);
			break;



		}

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

SeqStack.c

/*
	seqstack.c
*/
#define _CRT_SECURE_NO_WARNINGS 1
#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];	
	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];	

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

SeqStack.h

#pragma once
/*
	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);

小结

顺序栈是一种使用数组实现的栈结构。它的特点是插入和删除操作都在栈顶进行，可以快速访问栈顶元素。以下是对顺序栈的学习总结：

1. 定义：顺序栈是一种使用数组实现的栈结构，它具有固定大小，可以根据需要进行扩容或缩容。

2. 实现原理：顺序栈使用数组来存储数据元素，通过一个指针（通常称为top）来指示栈顶的位置。初始时，top指向-1，表示栈为空。

3. 入栈操作：将新的元素插入到栈顶，同时将top指针加1。当栈满时，即数组已经存满元素，无法继续入栈。

4. 出栈操作：将栈顶元素删除，同时将top指针减1。当栈为空时，即top指针为-1，无法进行出栈操作。

5. 获取栈顶元素：可以通过top指针获取栈顶元素的值，但不会将其从栈中删除。

6. 判空和判满：根据top指针的值进行判断，当top为-1时，栈为空；当top等于数组的最大索引值时，栈为满。

7. 应用场景：顺序栈适用于需要快速访问栈顶元素的场景，例如逆序输出、括号匹配、表达式求值等问题的解决。

总的来说，顺序栈是一种简单、高效的数据结构，常用于需要临时保存数据的场景。通过掌握顺序栈的基本操作和特点，可以更好地理解和应用栈结构。

参考资料

详解顺序栈-CSDN博客

百度以及AI

xxdillon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
顺序栈定义
10-13
### 顺序栈定义与实现详解 在数据结构与算法的学习中，栈是一种常见的线性数据结构，具有后进先出（LIFO）的特点。本文将深入解析“顺序栈”的概念、实现原理及其代码示例，旨在帮助读者理解并掌握顺序栈的内部机制...
顺序栈 C++
05-09
顺序栈 C++ 实现详解 顺序栈是计算机科学中的一种基本数据结构，它是一种先进先出（First-In-First-Out，FIFO）的数据结构。下面我们将详细介绍顺序栈的 C++ 实现。 顺序栈的定义 顺序栈（Sequential Stack）是一...
栈详解 顺序栈 基本操作 C语言实现 数据结构
weixin_63666347的博客
05-14 1175
一、栈 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 1.2栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些，因为数组在尾上插入数据的代价比较小 顺序栈基本操作 #include<stdio.h> #include<stdlib.h> #incl..
顺序栈的详解
qq_54938554的博客
10-19 2200
栈是一种特殊的数据结构，它的特点是后进先出（Last In First Out，LIFO）。栈是一种线性结构，它可以用来存储一组具有相同类型的数据元素。栈的基本操作包括压入（push）和弹出（pop），其中压入操作将数据元素添加到栈的顶部，弹出操作将栈顶的数据元素移除并返回。/* 堆空间 */int top;/* 栈顶指针 */}SeqStack;/* 1. 初始化 *//* 2. 进（入）栈 *//* 3. 出栈 *//* 4. 取栈顶元素 *//* 5. 栈为空？*/
栈详解（顺序栈和链栈）
o8699458的博客
08-08 1460
栈什么是栈？顺序栈链栈 什么是栈？ 栈是一种基本数据结构，因其拥有后进先出的特点（Last in First out），也就是LIFO，栈的一种常见用途就是用来判断一串字符中的括号是否有效。 括号的类型有{}、[]、()，“{[]}”像这样的就是有效的，而像"{[])"这样的就是无效的括号，这通常用于编译器的语法检查。 在内存的中使用也是一种栈，因函数调用会压栈，每调用一次压栈一次，当递归层次太深时，我们经常看到编译器报错：“Stack Overflow”,也就是栈溢出。 栈的主要操作有Push和Pop，入
数据结构——顺序栈详解
weixin_51785373的博客
10-20 1868
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
LwIP协议栈源码详解_LwIP_协议栈详解_
09-29
**LwIP协议栈源码详解** LwIP（Lightweight TCP/IP）是一个开源的、轻量级的网络协议栈，适用于嵌入式系统。它由瑞典Chalmers大学的Adiscon公司开发，旨在为资源有限的微控制器提供TCP/IP功能。LwIP在设计时考虑了...
c++数据结构--顺序栈
03-15
### C++ 实现顺序栈详解 #### 一、引言 在计算机科学中，栈（Stack）是一种只能在一端进行插入或删除操作的线性表，通常被称作“先进后出”（First In Last Out，FILO）或“后进先出”（Last In First Out，LIFO）...
C++模板实现顺序栈
12-20
C++模板实现顺序栈是一种高效且灵活的数据结构，它允许我们用一种通用的方式来处理不同类型的元素。顺序栈基于数组，其工作原理类似于生活中常见的栈，遵循“后进先出”（LIFO）的原则。在顺序栈中，所有的元素都是...
【初阶数据结构篇】单链表的实现（赋源码）
2301_79849925的博客
07-25 1513
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1228
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 429
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1157
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 2076
【代码】2024.7.24 作业。
《数据结构1800题》基础回合总结——第1章 绪论
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 459
前言：《数据结构1800》这本书相信大家或多或少都有所耳闻，收录了诸多不同档次学校的考研真题，因为和汤老师的1800撞名所以备受调侃。这1800道题目里面有选择有填空，也有简答和一些编程题，总的来说质量良莠不齐——亦或说没什么性价比。因此无论考研还是备战期末或者面试的同学，当学有余力的时候，再去看本题集的内容~注：基础阶段，强烈建议不要学算法题，这玩意对于大部分人的水平来说非常耽误效率——ACM佬不在此行列。因此本次刷题相当于基础阶段，只针对除了算法设计的一切基础题~答案如下：答案如下：答案如下： 这一部分
数据结构和算法入门
weixin_67852890的博客
07-25 1584
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
最新发布
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
顺序栈实现与操作详解
"这篇资料主要介绍了栈的基本操作在顺序栈中的实现，以及栈和队列这两种数据结构的特点和应用。" 在数据结构中，栈是一种非常重要的线性数据结构，其特点是后进先出（LIFO）。栈的操作通常包括初始化栈、入栈、出栈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值