顺序栈详解

Sx_____

于 2023-10-22 17:33:14 发布

阅读量276

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/Sx_____/article/details/133974994

版权

一、顺序栈的定义

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

二、顺序栈的特点

顺序存储：

采用地址连续的存储空间（数组）依次存储栈中数据元素。

空间利用率高：

可以动态分配，栈空间的起始位置和大小都可以动态变化。

存取速度快：

可以通过数组下标直接进行数据的存取，存取速度更快。

先进后出：

栈顶元素最后出栈，最先入栈。

三、顺序栈的基本运算

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

8、栈的应用

十进制转二进制：

/*十进制转换为二进制*/
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 '-':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op2 - op1;
			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;
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

四、完整代码

/*
	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[])
{
	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:
			if(empty(&S)){
				printf("栈是空的哦！\n");
				break;
			} 
			printf("确定要出栈（出栈后数据不可恢复,y|n）？\n");
			empty(&S);
			getchar(); 
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!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 '-':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op2 - op1;
			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;
		}
	}
	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;
}

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

五、运行结果

总结

以上就是顺序栈的基本介绍，本文简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出的原则，即在栈顶添加和删除元素。顺序栈在计算机科学中经常使用，因为它允许我们在高频率的情况下进行添加和删除操作。

Sx_____

关注

0
点赞
踩
0

收藏

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

顺序栈是栈的顺序实现。顺序栈是指利用顺序存储结构实现的栈。采用地址连续的存储空间（数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。以上就是顺序栈的基本介绍，本文简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出的原则，即在栈顶添加和删除元素。
复制链接

扫一扫