栈的应用_就近匹配_中缀后缀表达式

最新推荐文章于 2022-07-28 15:07:54 发布
最新推荐文章于 2022-07-28 15:07:54 发布
阅读量155 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44309282/article/details/107536887
版权

栈的应用

栈的应用_就近匹配

检测括号是否匹配的能力
算法思路
 从第一个字符开始扫描
 当遇见普通字符时忽略，
 当遇见左符号时压入栈中
 当遇见右符号时从栈中弹出栈顶符号，并进行匹配
 匹配成功：继续读入下一个字符
 匹配失败：立即停止，并报错
 结束：
 成功: 所有字符扫描完毕，且栈为空
 失败：匹配失败或所有字符扫描完毕但栈非空

//LinkStack.h
#ifndef LINKSTACK_H
#define LINKSTACK_H

#include <stdlib.h>
#include <stdio.h>

//链式栈的结点
typedef struct LINKNODE{
	struct LINKNODE* next;
}LinkNode;

//链式栈
typedef struct LINKSTACK{
	LinkNode head;
	int size;
}LinkStack;

//初始化函数
LinkStack* Init_LinkStack();
//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data);
//出栈
void Pop_LinkStack(LinkStack* stack);
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack);
//返回栈元素的个数
int Size_LinkStack(LinkStack* stack);
//清空栈
void Clear_LinkStack(LinkStack* stack);
//销毁栈
void FreeSpace_LinkStack(LinkStack* stack);

#endif

//LinkStack.c
#include"LinkStack.h"
//初始化函数
LinkStack* Init_LinkStack(){

	LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
	stack->head.next = NULL;
	stack->size = 0;

	return stack;
}
//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data){

	if (stack == NULL){
		return;
	}

	if (data == NULL){
		return;
	}
	
	data->next = stack->head.next;
	stack->head.next = data;
	stack->size++;
}
//出栈
void Pop_LinkStack(LinkStack* stack){
	if (stack == NULL){
		return;
	}

	if (stack->size == 0){
		return;
	}
	
	//第一个有效结点
	LinkNode* pNext = stack->head.next;
	stack->head.next = pNext->next;

	stack->size--;
}
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack){
	if (stack == NULL){
		return NULL;
	}
	if (stack->size == 0){
		return NULL;
	}
	return stack->head.next;
}
//返回栈元素的个数
int Size_LinkStack(LinkStack* stack){
	if (stack == NULL){
		return -1;
	}
	return stack->size;
}
//清空栈
void Clear_LinkStack(LinkStack* stack){
	if (stack == NULL){
		return;
	}
	stack->head.next = NULL;
	stack->size = 0;
}
//销毁栈
void FreeSpace_LinkStack(LinkStack* stack){
	if (stack == NULL){
		return;
	}
	free(stack);
}


//栈的应用_就近匹配.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include"LinkStack.h"

typedef struct MYCHAR{
	LinkNode node;
	char* pAddres;
	int index;
}MyChar;

int IsLeft(char c){
	return c == '(';
}

int IsRight(char c){
	return c == ')';
}

MyChar* CreateMyChar(char* p,int index){
	MyChar* mychar = (MyChar*)malloc(sizeof(MyChar));
	mychar->pAddres = p;
	mychar->index = index;

	return mychar;
}

void ShowError(char* str,int pos){
	printf("%s\n",str);
	for (int i = 0; i < pos;i ++){
		printf(" ");
	}
	printf("A");
}

int main(void){

	char* str = "1+2+6(dsf)df)sflp(sdfs)";

	//创建栈容器
	LinkStack* stack = Init_LinkStack();

	char* p = str;
	int index = 0;
	while (*p != '\0'){
	
		//如果左括号 直接进栈
		if (IsLeft(*p)){
			Push_LinkStack(stack, (LinkNode*)CreateMyChar(p,index));
		}

		//如果是右括号 从栈顶弹出元素 判断是不是左括号
		if (IsRight(*p)){
			if (Size_LinkStack(stack) > 0){
				MyChar* mychar = (MyChar*)Top_LinkStack(stack);
				if (IsLeft(*(mychar->pAddres))){
					Pop_LinkStack(stack);
					free(mychar);
				}
			}
			else{
				printf("右括号没有匹配的左括号:\n");
				ShowError(str,index);
				break;
			}
		}

		p++;
		index++;
	}


	while (Size_LinkStack(stack) > 0){
		MyChar* mychar = (MyChar*)Top_LinkStack(stack);
		printf("左括号没有匹配的右括号:\n");
		ShowError(str, mychar->index);
		Pop_LinkStack(stack);
		free(mychar);
	}
	printf("\n");

	system("pause");
	return 0;
}

中缀表达式和后缀表达式

后缀表达式
将运算符放在数字后面 ===》 符合计算机运
中缀表达式
我们习惯的数学表达式 ===》符合人类思考习惯

中缀表达式转后缀表达式

8 + ( 3 – 1 ) * 5 ===> 8 3 1 – 5 * +

遍历中缀表达式中的数字和符号：
 对于数字：直接输出
 对于符号：
 左括号：进栈
 运算符号：与栈顶符号进行优先级比较
若栈顶符号优先级低：此符号进栈
（默认栈顶若是左括号，左括号优先级最低）
若栈顶符号优先级不低：将栈顶符号弹出并输出，之后进栈
 右括号：将栈顶符号弹出并输出，直到匹配左括号
遍历结束：将栈中的所有符号弹出并输出
在这里插入图片描述

//mian.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LinkStack.h"

//判断是否是数字
int IsNumber(char c){
	return c >= '0' && c <= '9';
}

//判断是不是左括号
int IsLeft(char c){
	return c == '(';
}

//判断是不是右括号
int IsRight(char c){
	return c == ')';
}

//判断是不是运算符号
int IsOperator(char c){
	return c == '+' || c == '-' || c == '*' || c == '/';
}

//返回运算符号优先级
int GetPriority(char c){
	if (c == '*' || c == '/'){
		return 2;
	}
	if (c == '+' || c == '-'){
		return 1;
	}
	return 0;
}

typedef struct MYCHAR{
	LinkNode node;
	char* p;
}MyChar;

//数字操作
void NumberOperate(char* p){
	printf("%c", *p);
}

//创建MyChar
MyChar* CreateMyChar(char* p){
	MyChar* mychar = (MyChar*)malloc(sizeof(MyChar));
	mychar->p = p;
	return mychar;
}

//左括号的操作
void LeftOperate(LinkStack* stack, char* p){
	Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
}

//右括号操作
void RightOperate(LinkStack* stack){

	//先判断栈中有没有元素
	while (Size_LinkStack(stack) > 0){
		MyChar* mychar = (MyChar*)Top_LinkStack(stack);
		//如果匹配到左括号
		if (IsLeft(*(mychar->p))){
			Pop_LinkStack(stack);
			free(mychar);
			break;
		}
		//输出
		printf("%c", *(mychar->p));
		//弹出
		Pop_LinkStack(stack);
		//释放内存
		free(mychar);
	}
}

//运算符号的操作
void OperatorOperate(LinkStack* stack, char* p){

	//先取出栈顶符号
	MyChar* mychar = (MyChar*)Top_LinkStack(stack);
	if (mychar == NULL){
		Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
		return;
	}
	//如果栈顶优先级低于当前字符的优先级 直接入栈
	if (GetPriority(*(mychar->p)) < GetPriority(*p)){
		Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
		//return;
	}

	//如果栈顶符号优先级不低
	else{

		while (Size_LinkStack(stack) > 0){

			MyChar* mychar2 = (MyChar*)Top_LinkStack(stack);

			//如果优先级低 当前符号入栈
			if (GetPriority(*(mychar2->p)) < GetPriority(*p)){
				Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
				return;
			}

			//输出
			printf("%c", *(mychar2->p));
			//弹出
			Pop_LinkStack(stack);
			//释放
			free(mychar2);
		}
	}

}


int main01(void){

	char* str = "8+(3-1)*5-6";
	char* p = str;

	//创建栈
	LinkStack* stack = Init_LinkStack();

	while (*p != '\0'){

		//如果是数字
		if (IsNumber(*p)){
			NumberOperate(p);
		}

		//如果左括号 直接进栈
		if (IsLeft(*p)){
			LeftOperate(stack, p);
		}

		//如果是右括号
		if (IsRight(*p)){
			RightOperate(stack);
		}

		//如果是运算符号
		if (IsOperator(*p)){
			OperatorOperate(stack, p);
		}
		p++;
	}

	while (Size_LinkStack(stack) > 0){
		MyChar* mychar = (MyChar*)Top_LinkStack(stack);
		printf("%c", *(mychar->p));
		Pop_LinkStack(stack);
		free(mychar);
	}

	system("pause");
	return 0;
}

根据后缀表达式求解

8 3 1 – 5 * +
遍历后缀表达式中的数字和符号
 对于数字：进栈
 对于符号：
 从栈中弹出右操作数（即放到符号的右边）
 从栈中弹出左操作数（即放到符号的左边）
 根据符号进行运算
 将运算结果压入栈中
遍历结束：栈中的唯一数字为计算结果
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LinkStack.h"

int IsNumber2(char c){
	return c >= '0' && c <= '9';
}

typedef struct MYNUM{
	LinkNode node;
	int val;
}MyNum;


int Caculate(int left,int right,char c){

	int ret = 0;
	switch (c)
	{
	case '+':
		ret = left + right;
		break;
	case '-':
		ret = left - right;
		break;
	case '*':
		ret = left * right;
		break;
	case '/':
		ret = left / right;
		break;
	default:
		break;
	}

	return ret;
}

int main(void){
	
	//后缀表达式
	char* str = "831-5*+";
	char* p = str;

	//创建栈
	LinkStack* stack = Init_LinkStack();

	while(*p != '\0'){
		//如果是数字 直接入栈
		if (IsNumber2(*p)){
			MyNum* num = (MyNum*)malloc(sizeof(MyNum));
			num->val = *p - '0';		//字符转数字
			Push_LinkStack(stack, (LinkNode*)num);
		}
		else{
		
			//先从栈中弹出右操作数
			MyNum* right = (MyNum*)Top_LinkStack(stack);
			int rightNum = right->val;
			Pop_LinkStack(stack);
			free(right);
			//取出左操作数
			MyNum* left = (MyNum*)Top_LinkStack(stack);
			int leftNum = left->val;
			Pop_LinkStack(stack);
			free(left);
			
			int ret = Caculate(leftNum, rightNum,*p);
			//结果入栈
			MyNum* num = (MyNum*)malloc(sizeof(MyNum));
			num->val = ret;
			Push_LinkStack(stack, (LinkNode*)num);
		}
		p++;
	}

	if (Size_LinkStack(stack) == 1){
		MyNum* num =  (MyNum*)Top_LinkStack(stack);
		printf("运算结果是:%d\n",num->val);
		Pop_LinkStack(stack);
		free(num);
	}

	//释放栈
	FreeSpace_LinkStack(stack);

	system("pause");
	return 0;
}
L&Li
关注
专栏目录
数据结构（七） -- C语言版 -- 栈和队列 - 栈的应用解析
青椒*^_^*凤爪爪的博客
03-15 4886
本文中没有涉及到很多的相关理论知识，也没有做深入的了解，所以，您如果是想要系统的学习、想要多学习关于理论的知识等，那么本文可能并不合适您。 本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
数据结构 栈 5
云中自有锦书
02-24 244
目录： Stack基本概念：Stack的常用操作 栈的顺序存储设计与实现 1）基本概念                    2）设计与实现 栈的链式存储设计与实现 1）基本概念                   2）设计与实现 栈的应用 1.Stack  基本概念 1）栈是一种特殊的线性表 栈仅能在线性表的一端进行操作：        栈顶（Top）:允许操作的一端   ...
方括号：Visual Studio代码扩展，以预览与检查的右方括号匹配的代码的开头行
02-28
括号窥视 此扩展名可帮助您在检查匹配的右括号时查看包含左括号的代码行。 如果在当前视口中看不到包含左括号的代码行，则在编辑器的第一行中显示预览。 适用于： 大括号 { ... } 括弧 （ ... ） 方括号 [ ... ] 标签<tag> ... <tag> 特征 工作于： 选择带有右括号/标签的文本 将刀架移至或接近关闭支架/标签 悬停在右方括号/标签上方或附近 适用于任何包含方括号的编程语言： Javascript * .js 打字稿* .ts 萨斯* .scss CSS * .css JSON * .json Dart* .dart Java * .java PHP * .php C，C＃，C ++，Objective-C，Objective C ++ * .c * cs * .cpp .m * .h 可与任何包含标记的基于标记的语言一起使用：
25-栈的应用—就近匹配
网络安全
06-13 335
  就近匹配就是当给定一个表达式时，然后进行匹配表达式中的括号是否成对出现。   例如给定表达式：4+2-(6/3)-(3+2)*4+( (2-1)，我们在这个表达式中发现有一个左括号没有对应的右括号进行匹配。 就近匹配思路如下：   1. 指针p扫描表达式的每个字符，如果是普通字符则忽略，直接扫描下一个   2. 如果扫描到左括号字符，直接进栈   3. 如果扫描到右括号字符，进一步判...
数据结构-栈的应用就近匹配（7）
weixin_36455036的博客
05-30 166
算法思路当需要检测成对出现，但不相邻的事物时，可以使用栈“后进先出”的特性，几乎所有的编译器都具有检测括号是否匹配的能力。从第一个字符开始扫描     当遇到普通字符时忽略    当遇到左符号时压入栈中    当遇到右符号时从栈中弹出栈顶符号并进行匹配           匹配成功：继续读入下一个字符           匹配失败： 立即停止报错。结束：成功：所有字符扫描完毕且栈为空失败：匹配失败...
数据结构之线性表——就近匹配（栈的应用）
小强博客
03-23 272
1 就近匹配几乎所有的编译器都具有检测括号是否匹配的能力，如何实现编译器中符号的成对检测？例如：检测如下一串代码：2 算法思路从第一个字符开始扫描，当遇见普通字符时忽略，当遇见左符号时压入栈中，当遇见右符号时从栈中弹出栈顶符号，并进行匹配，匹配成功：继续进入下一个字符；匹配失败：立即停止，报告错误。结束：成功，所有字符扫描完毕，且栈为空。失败：匹配失败或所有字符扫描完毕但栈非空。当需要检测成对出现...
栈
m0_53157173的博客
03-02 174
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX 1024 //栈:注意和动态数组的区别： //动态数组这里用的指针是二级指针因为数组的大小无法提前确定，并且用户数组类型无法确定，要用void*一级指针来接收 //所以要在堆区动态开辟数组存放void*类型数据要用二级指针来接收 //这里的栈已经知道数组的最大长度，因此..
栈的一些基本的应用与实现
07-29
1. 符号就近匹配：在编程语言解析和编译过程中，符号就近匹配是常见的应用场景。例如，当解析括号、引号等配对符号时，我们可以通过栈来检查一对括号是否正确匹配。每当遇到一个左括号，就将其压入栈中；遇到右括号...
传智播客扫地僧视频讲义源码
04-03
18_栈的属性和buf地址增长方向是两个不同的概念 19_函数调用模型_主调函数和被调用函数 20_课堂答疑_函数调用流程入栈出栈过程 21_指针也是一种数据类型_基础 22_指针也是一种数据类型_强化_传智扫地僧 源码及文档 ...
3、栈和队列
叶强的博客
07-25 256
参考文献： 1. Python就业班 2. 3.
C#面试题：括号配对
qq_45063234的博客
06-15 264
最近面试被问到关于括号配对的问题，之前没有刷到过关于栈空间存储方面的题，于是就挂掉了，回家从网上查了一些资料，发现了这篇博客https://blog.csdn.net/wucdsg/article/details/99009205，发现不太适合我，于是微微做了一些调整，如下： 面试题为： （ [ ） 错误 出现单个不匹配的括号为错误; （ { [ } ） ] 错误 成对出现但顺序错误也为错误; （ [ ] ） 正确 （）[] {}必须
21、栈的应用-就近匹配
weixin_33860722的博客
09-08 67
main.c /* 就近匹配，找出不匹配的符号用箭头A标注出来 这里只写了小括号的匹配 */ #define _CRT_SECURE_NO_WARNING #include<stdio.h> #include<stdlib.h> #include<string.h> #include"Stack.h" typedef str...
栈的应用（就近匹配）
lihuaicheng17的博客
03-19 347
#include <stdio.h> #include <stdio.h> #include <string.h> #define MAX 1024 struct SStack { void* data[MAX]; int m_size; }; typedef void* SeqStack; //初始化栈 SeqStack init_SeqStack() { struct SStack* myStack = malloc(sizeof(struct SSta.
栈的应用——就近匹配 （C语言）
u011713916的博客
09-23 375
就近匹配 在开发的过程中，我们常常遇到成对出现的符号，比如"(" 与")"，如果算式中仅仅出现其中一个，则说明算式错误。运用栈一数据结构模型，可以很好进行匹配。 算法思路： 1、从第一个字符开始扫描 2、遇见普通字符时忽略 3、当遇见左括号时压入栈中 4、当遇见右括号时弹出返回栈顶元素，并进行匹配 5、匹配成功，进入下一个字符 6、匹配失败，立即停止并进行报错 7、结束： 成功：所有字符匹配完毕，且栈为空 失败：匹配失败或者所有字符扫描完毕但是栈为非空 代码 "seqStack.h"文件 包含了栈的模型结构
最近邻算法（KNN算法）
abc1234564546的博客
07-28 1万+
最近邻算法（KNN算法）
【栈——括号匹配】
piano_diano的博客
12-01 91
#include<stdio.h> #include<stdlib.h> #define MAX_SIZE 1024 #define SEQSTACK_True 1 #define SEQSTACK_FALSE 0 /** 扫描字符串，如果碰到左括号，直接入栈； 如果碰到右括号，从栈顶弹出括号， 判断是否是左括号，如果是则匹配成功 **/ //数组模拟栈的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值