详解顺序栈

weixin_53454890

已于 2023-10-26 18:51:40 修改

阅读量170

点赞数

文章标签：数据结构算法

于 2023-10-20 13:56:50 首次发布

本文链接：https://blog.csdn.net/weixin_53454890/article/details/133944079

版权

一.定义

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

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

数据结构：顺序栈是由一个一维数组和一个指示栈顶位置的整数构成的数据结构。
操作：顺序栈支持两主要操作：
- 入栈（Push）：将元素压入栈顶。这是在数组的栈顶位置插入一个新元素。
- 出栈（Pop）：将栈顶元素弹出。这是从栈顶位置移除元素。
特点：
- 栈顶指针：通常用一个整数变量（例如，top）来表示栈顶的位置。栈顶指针指向栈顶元素的位置，初始时可以设为-1。
- 队列大小：通常栈的大小是固定的，取决于数组的大小。一旦栈满了，就不能再进行入栈操作。
- 空栈检测：通过栈顶指针的位置来检测栈是否为空。当栈顶指针为-1时，表示栈为空。
- 溢出检测：通过栈顶指针的位置来检测栈是否已满。当栈顶指针等于数组的最大索引时，表示栈已满。
应用：顺序栈常用于需要实现后进先出操作的场景，如表达式求值、括号匹配、函数调用管理等。

二．特点

基于数组实现：顺序栈是基于数组的数据结构，栈中的元素存储在数组中，通过数组的索引来访问栈中的元素。
后进先出（LIFO）：栈是一种后进先出的数据结构，即最后入栈的元素最先出栈，类似于堆叠物品。
固定大小：顺序栈的大小通常是固定的，由数组的大小决定。一旦栈满了，无法再进行入栈操作。
栈顶指针：通常使用一个整数变量（如top）来表示栈顶的位置，该指针指向栈顶元素的位置。初始时，可以将栈顶指针设为-1。
空栈检测：通过栈顶指针的位置来检测栈是否为空。当栈顶指针等于-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.入栈

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）的原则。顺序栈使用数组来存储栈中的元素，提供了一组基本操作，包括初始化、入栈、出栈、取栈顶元素、检查栈是否为空、检查栈是否满、以及销毁栈。

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

初始化（init）： 在使用顺序栈之前，需要进行初始化，为数组分配内存，并设置栈顶指针等参数。初始化操作允许你指定栈的最大容量。
入栈（push）： 将元素压入栈顶。这是通过将元素添加到数组中的栈顶位置（栈顶指针上方）来实现的。栈顶指针会相应地增加。
出栈（pop）： 从栈顶移除元素。这是通过将栈顶指针下移一个位置来实现的。出栈操作通常返回被移除的元素的值。
取栈顶元素（get_top）： 获取栈顶元素的值，但不将其从栈中移除。这个操作只是读取栈顶元素的值。
栈是否为空（empty）： 检查栈是否为空。如果栈顶指针为-1，那么栈被认为是空的。
栈是否满（full）： 检查栈是否已满。如果栈顶指针等于栈的最大容量减1，那么栈被认为是满的。
销毁（destroy）： 释放分配给栈的内存。这是为了防止内存泄漏，通常在不再需要栈时调用。

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

weixin_53454890

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
详解顺序栈

顺序栈（Sequential Stack）是一种基于数组的数据结构，用于实现栈（Stack）的操作。栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，顺序栈就是在数组的基础上实现的栈结构。：顺序栈是由一个一维数组和一个指示栈顶位置的整数构成的数据结构。：顺序栈常用于需要实现后进先出操作的场景，如表达式求值、括号匹配、函数调用管理等。
复制链接

扫一扫