详解顺序栈

番一星

已于 2023-10-20 17:40:56 修改

阅读量114

点赞数

文章标签：开发语言数据结构 c语言

于 2023-10-20 16:52:51 首次发布

本文链接：https://blog.csdn.net/weixin_55668080/article/details/133946024

版权

顺序栈的定义

栈（stack）又名堆栈，它是一种运算受限的线性表，要严格遵循先进后出的原理。

顺序栈：用顺序结构存储的栈

特点：简单方便，但是容易溢出（上溢或者下溢）

顺序栈的实现

1.顺序栈的定义

顺序栈被定义为一个结构体类型，其中Datatype为栈元素的数据类型，data为一个一维数组，用于存储栈中的数据元素，top用于几率栈顶所在的位置。

/* 顺序栈的定义 */
typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack

2.顺序栈的初始化

初始化操作既创建一个空栈，把栈顶指针设为-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;
}

3.判断栈空和栈满

判断栈空和栈满都是用栈顶指针top来判断，若top为-1则栈空，若top为MAX-1既为栈满（MAX为给定的顺序栈存储空间的总分配量）。

/* 取顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

	*x = S->data[S->top];	/*栈顶元素赋值给x*/

	return 0;
}

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

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

4.顺序栈的进栈和出栈

入栈要先判断栈是否已满，若没满则先将top指针+1，再将数据放入栈顶位置上。

出栈要先判断栈是否已满，若没满则先将栈顶数据带出，再使top指针-1；注：出栈只是栈顶指针改变，元素还在数组内。

/* 进栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}

	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

/* 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	

	return 0;
}

5.销毁栈

释放顺序栈所占用的内存空间。

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

完整代码

/* 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 */
#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;
}

/* main.c*/
#include <stdio.h>
#include <string.h>
#include <stdlib.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;
	
	int result;
    char welcome[] = "\n\
    ★╭－－－－－－╮☆☆☆☆☆☆╭－－－－－－╮\n\
    ★╰╮八方来财╭╯◢ █ ◣◢ █ ◣╰╮期末高分╭╯\n\
    ★╭╯╰－－－╯╰╮██自  由██╭╯╰－－－╯╰╮\n\
    ★║◢ █ ◣◢ █ ◣║◥ █快乐█ ◤║◢ █ ◣◢ █ ◣║\n\
    ★║██████████║　◥ ██ ◤　║██████████║ \n\
    ★║◥ █真心█ ◤║　        ║◥ █祝福█ ◤║\n\
    ★║　◥ ██ ◤　║☆ ☆ ☆ ☆ ☆║　◥ ██ ◤　║\n\
    ★║　 ◥ ◤　 ║☆ 事事如意☆ ║ ◥ ◤　║\n\
         \\   ☆ 祝我 . 也祝你！☆\n\n";
	int i = 0; 
	int m = 0; 
	int n = 0;
    for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<10000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}
	printf("\n\n\n");
	
	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:
			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");
		}

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

效果图

小结

本次学习了顺序栈，了解了顺序栈的进栈，出栈，销毁并知道了判断是否为空和为满......比较难的就是循序表的应用（本次实验用了进制）。补充如下：

顺序栈的主要应用场景包括：

表达式求值：后缀表达式（逆波兰表示法）是一种常见的表达式表示方法，它不需要使用括号来表示优先级，而是通过将操作符放在操作数的后面来表示。顺序栈可以用于后缀表达式的求值，其中入栈操作用于将操作数压入栈中，出栈操作和查看栈顶元素用于依次处理后缀表达式中的操作符和操作数。
数据结构中的辅助数据结构：顺序栈可以作为数据结构中的辅助数据结构，例如在实现链表、树等数据结构时，可以使用顺序栈来辅助进行节点的插入、删除等操作。
程序的内存管理：程序在运行时需要使用动态内存分配，而顺序栈可以用于管理这些动态分配的内存块。例如，可以使用顺序栈来保存程序的函数调用栈，以便在函数调用时压入参数和保存局部变量，函数返回时弹出参数和恢复局部变量。

参考文献

数据结构——顺序栈_黄憨憨_的博客-CSDN博客

番一星

关注

0
点赞
踩
0

收藏

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

栈（stack）又名堆栈，它是一种运算受限的线性表，要严格遵循先进后出的原理。顺序栈：用顺序结构存储的栈特点：简单方便，但是容易溢出（上溢或者下溢）顺序栈被定义为一个结构体类型，其中Datatype为栈元素的数据类型，data为一个一维数组，用于存储栈中的数据元素，top用于几率栈顶所在的位置。/* 顺序栈的定义 *//* 堆空间 */int top;/* 栈顶指针 */}SeqStack。
复制链接

扫一扫