顺序栈与栈的应用（后缀表达式）

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

栈的定义

栈又名堆栈，只允许在一端进行插入或删除操作的线性表。首先，栈是一种线性表，但限定这种线性表只能在某一段进行插入和删除操作。

顺序栈定义

  • 栈的顺序存储结构简称为顺序栈
  • 顺序栈采用一堆数组存储，下标从零开始。
  • 设置变量top来记录当前栈顶位置（下标）
  • 变量top可以变化（上下移动）

特点：

访问速度快

先进后出

临时性，堆内存只有在malloc之后的期间才可被访问

容量性，当栈中元素个数达到容量时，就无法再插入新的元素

操作概述

初始化、出入栈、判定是否为空或者满、销毁、十进制转换二进制、后缀表达式计算

代码的实现

结构：

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

初始化：

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

执行结果： 

十进制转换二进制

/*十进制转换为二进制*/
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;
		}
	}
	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("请选择（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）？");
			flushall(stdin);
			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:
			printf("确定要销毁（销毁后数据不可恢复,y|n,n）？");
			fflush(stdin);//  清空输入标准流stdin缓冲区
			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;
		}

	} 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;
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&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;
}

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. 无论是存数据还是取数据，都必须遵循"先进后出"的原则，即最先进栈的元素最后出栈
  3. 栈顶指的是允许插入和删除元素的一端，栈底指的是不允许插入和删除元素的一端
  4. 存在栈中的数据大小与生存期必须是确定的，缺乏灵活性
  5. 运行时动态分配内存，存取速度较慢

参考文献

《数据结构C语言》--李刚  刘万辉 

栈（计算机术语）_百度百科 (baidu.com)

栈的特点_百度知道 (baidu.com)

DDQ337
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值