数据结构与算法分析实验4 [进阶]完成简易计算器（较复杂表达式求值），和双端队列、共享栈

最新推荐文章于 2024-11-12 18:03:10 发布
最新推荐文章于 2024-11-12 18:03:10 发布
阅读量482 收藏 4
点赞数 9
分类专栏： 数据结构与算法分析实验 文章标签： 数据结构 算法 c++ visualstudio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81290340/article/details/137412285
版权

文章目录

表达式求值（通过类实现）基本原理

这里主要通过链式栈进行操作。表达式求值的原理在于将一段复杂的中缀运算转变为前缀表达式、后缀表达式，通过传入的计算序列，创建运算符栈和数值栈，进行运算，通过栈的规则，不断进行以下步骤（以后缀表达式为例）：数字入数字栈，运算符入运算符栈，如果符号优先级比已经在栈中的符号优先级高，先进行计算，如果等于或低于前者，从数字栈取出两个数字，符号栈取出前面那个运算符进行运算，结果存放到数字栈中。其难点在于如何比较优先级，如何让处理括号问题。

4.3 表达式求值（类实现）

在后面，或许会利用类的结合特性，给出更好的表达式求值方法，目前阶段主要是进行逻辑思维运算

4.3.1 NodeSatck.h

简单写一个链栈即可

#pragma once
#include<iostream>
typedef int Data;

struct Node {
	Data data;
	Node* next;
};

class NodeSatck {
public:
	NodeSatck();
	~NodeSatck();
	void init();
	void push(Data data);
	Data pop();
	void destory();
	int len();
	Data read();
	void clear();
private:
	int length;
	Node* top;
	Node* base;
};

4.3.2 NodeSatck.cpp

链栈的简单实现，与上一篇博客内容相似

#include"NodeSatck.h"

NodeSatck::NodeSatck() {
	init();
}

NodeSatck::~NodeSatck() {
	destory();
}

void NodeSatck::init() {
	top = new Node;
	base = new Node;
	top->next = base;
	base->next = nullptr;
	length = 0;
}

void NodeSatck::push(Data data) {
	Node* fresh = new Node;
	fresh->data = data;
	fresh->next = top->next;
	top->next = fresh;
	length++;
}

Data NodeSatck::pop() {
	Node* del = top->next;
	top->next = del->next;
	Data data = del->data;
	length--;
	delete del;
	return data;
}

void NodeSatck::destory() {
	length = 0;
	Node* move = top;
	Node* del;
	while (move) {
		del = move;
		move = move->next;
		delete del;
	}
}

int NodeSatck::len() {
	return length;
}

Data NodeSatck::read() {
	if (length == 0) exit(22);
	else {
		return top->next->data;
	}
}

void NodeSatck::clear() {
	Node* move = top->next;
	Node* tmp = nullptr;
	while (move->next != nullptr) {
		tmp = move;
		move = move->next;
		delete tmp;
		length--;
	}
	top->next = base;
}

4.3.3 main.cpp

#include"NodeSatck.h"
using namespace std;
#pragma warning(disable:4996)
float operate(float f, Data opt, float t);
char pre(char a, char b);
int isOperator(char c);
void Optpush();
NodeSatck Op = {};
NodeSatck Val = {};
NodeSatck bExpress = {};
NodeSatck Express = {};
char optr[7] = { '+','-','x','/','(',')','#' };
char prior[7][7] = {
	//+   -   x   /   (   )   #  操作符/栈中
	{'o','o','i','i','i','o','o'},// +
	{'o','o','i','i','i','o','o'},// -
	{'o','o','o','o','i','o','o'},// x
	{'o','o','o','o','i','o','o'},// /
	{'i','i','i','i','i','e','n'},// (
	{'i','i','i','i','e','i','i'},// )
	{'i','i','i','i','i','n','e'} // #
};

int main() {
	Op.push('#');
	//表达式入队列，以两个栈形式完成
	string str;
	cin>>str;
	int length = str.length();
	for (int i = 0; i < length; i++) {
		bExpress.push(str.c_str()[i]);
		cout << bExpress.read() << ' ' << endl;
		cout << i+1<<endl;
	}
	cout << "len:" << bExpress.len() << endl;
	while(bExpress.len()){
		Express.push(bExpress.pop());
		cout << Express.read() << ' ' << endl;
	}
	//表达式入栈操作
	int tmp = 0;
	while (Express.len()!=0) {
		//数字入栈，由于读取的是字符，所以还要处理为数字
		Data ret = (Data)Express.read();
		ret -= '0';
		if (ret >= 0 && ret <= 9) {
			tmp = tmp * 10 + ret ;
			std::cout << "read: "<< ret << std::endl;
			Express.pop();
		}
		else{								//遇到操作符
			if (tmp != 0) {
				Val.push(tmp);				//先将数字传入数字栈
				std::cout << "val push: " << tmp << std::endl;
			}
			tmp = 0;
			//符号入栈,并进行操作
			Op.push(Express.pop());
			Optpush();
		}
	}
	cout << Op.len() << endl;
	std::cout<<Val.pop();
}

float operate(float f, Data opt, float t) {
	cout << "calculating" << endl;
	switch (opt) {
	case '+':return f + t; break;
	case '-':return f - t; break;
	case 'x':return f * t; break;
	case '/':return f / t; break;
	default:exit(-1);
	}
}

//栈中符号，即将入栈符号
char pre(char a, char b) {
	int i = 0; int j = 0;
	while (optr[i] != a) i++;
	while (optr[j] != b) j++;
	cout << prior[i][j] << endl;
	return prior[i][j];
}
//判断是否是合法操作符
int isOperator(char c) {
	for (int i = 0; i < 7; i++)
		if (c == optr[i]) {
			return 1;
		}
	return 0;
}

void Optpush() {
	Data a;
	Data ret;
	if (isOperator(Op.read())) {		//如果是符号
		cout << "is operator!" << endl; 
		Data tmp = Op.pop();			//传出运算符
		switch (pre(Op.read(), tmp)) {	//和前一个运算符比较得到优先级
		case 'i':						//如果后一个运算符优先级高
			Op.push(tmp);
			break;
		case 'e':
			Op.pop();
			cout << "equal" << endl;
			break;
		case 'o':
			a = Val.pop();
			ret = (Data)operate(Val.pop(), Op.pop(), a);
			cout << ret << endl;
			Val.push(ret);
			Op.push(tmp);
			cout << "new operator" << endl;
			if (tmp == ')' || tmp == '#') {
				Optpush();
			}
			break;
		case 'n':exit(1);
		}
	}
	else exit(2);
}

4.3.4 程序运行结果（注释掉一些过程输出后）

在这里插入图片描述

4.4共享栈(单文件实现)

一个数组，但是由自下而上生长的栈和自上而下生长的栈组成

4.4.1 main.cpp

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define MAX_DEF_CAPACITY 20 

typedef int Data;
typedef struct _CoStack {
	Data* base;
	Data* top1;
	Data* top2;
}CoStack,*pCostack;
void coInit(CoStack* cos);
void coPush(CoStack* cos, int i, Data add);
Data coPop(CoStack* cos, int i);
Data coRead(CoStack cos, int i);
int* getLen(CoStack);
void coDes(CoStack* cos);

int main() {
	CoStack cos;
	coInit(&cos);
	for (int i = 0; i < 11; i++) {
		coPush(&cos, 1, i);
		coPush(&cos, 2, i);
	}
	int* ret = getLen(cos);
	printf("maxlen:%d  curlen1:%d  curlen2:%d  remain:%d\n",ret[0],ret[1],ret[2],ret[3]);
	for (int i = 0; i < 11; i++) {
		printf("1 pop: %d   ", coPop(&cos, 1));
		printf("2 pop: %d\n", coPop(&cos, 2));
	}
}
void coInit(CoStack* cos){
	cos->base = (Data*)malloc(MAX_DEF_CAPACITY * sizeof(Data));
	cos->top1 = &cos->base[0];
	cos->top2 = &cos->base[MAX_DEF_CAPACITY - 1];
}
void coPush(CoStack* cos, int i, Data add) {
	if (cos->top1-1 == cos->top2) { printf("Full! Invalid push!\n"); return; }
	if (i == 1) {
		cos->top1[0] = add;
		printf("1 push %d   ",add);
		if (++cos->top1 == cos->top2 + 1) printf("Now I'am full!\n");
	}
	else if (i == 2) {
		cos->top2[0] = add;
		printf("2 push %d\n", add);
		if (--cos->top2 == cos->top1 - 1) printf("Now I’m full!\n");
	}
	else exit(-1);
}
Data coPop(CoStack* cos, int i) {
	if (i == 1&& cos->top1!=&cos->base[0]) {
		cos->top1--;
		return cos->top1[0];
	}
	else if (i == 2&&cos->top2!=&cos->base[MAX_DEF_CAPACITY-1]) {
		cos->top2++;
		return cos->top2[0];
	}
	else {
		printf("Invalid pop!\n");
		exit(-3);
	}
}
Data coRead(CoStack cos, int i) {
	if (i == 1)return cos.top1[-1];
	else if (i == 2)return cos.top2[1];
	else { 
		exit(-3);
		return 0;
	}
}
int* getLen(CoStack cos) {
	int ret[4] = {};
	ret[0] = MAX_DEF_CAPACITY;					    //最大容量
	ret[1] = cos.top1 - cos.base;						    //1的容量
	ret[2] = &cos.base[MAX_DEF_CAPACITY-1] - cos.top2;	//2的容量
	ret[3] = cos.top2 - cos.top1 + 1;					    //剩余容量
	return ret;
}
void coDes(CoStack* cos) {
	free(cos->base);
}

4.4.2 当最大容量为20时，效果如下：

在这里插入图片描述

4.5双端队列

4.5.1 DQueue.h:

#pragma once
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>


typedef int Data;
typedef struct _SqStack {
	Data* data;
	int curlen;
}SqStack;

//			我们可以用栈来实现双端队列：
//基础思想：正向入栈和反向出栈可以看作一个队列，
//        反向入栈和正向出栈又可以看作一个队列。
//		  将栈顶看作队头，我们写出如下代码：

typedef struct _SqStack DQueue, * pDQueue;
void fftt(pDQueue dq);//翻转dq
void push_front(DQueue* dq, Data add);
Data pop_front(DQueue* dq);
void push_back(DQueue* dq, Data add);
Data pop_back(DQueue* dq);
//栈操作
void initStack(SqStack* stack);
void push(SqStack* stack, Data data);
Data pop(SqStack* stack);
Data getLast(SqStack stack);
Data getFirst(SqStack stack);
int getLength(SqStack stack);
int isEmpty(SqStack stack);
void clearStack(SqStack* stack);
void destoryStack(SqStack* stack);

4.5.2 DQueue.cpp

void fftt(pDQueue dq){
	Data* fresh = (Data*)malloc(getLength(*dq) * sizeof(Data));
	for (int i = 0; i < dq->curlen; i++) {
		fresh[dq->curlen - 1 - i] = dq->data[i];
	}
	free(dq->data);
	dq->data= fresh;
}

void push_front(DQueue* dq, Data add){
	push(dq, add);
}

Data pop_front(DQueue* dq){
	return pop(dq);
}

void push_back(DQueue* dq, Data add){
	fftt(dq);
	push(dq, add);
	fftt(dq);
}

Data pop_back(DQueue* dq){
	fftt(dq);
	Data del = pop(dq);
	fftt(dq);
	return del;
}

void initStack(SqStack* stack) {
	stack->data = NULL;
	stack->curlen = 0;
}

void push(SqStack* stack, Data data) {
	Data* fresh = (Data*)malloc((stack->curlen + 1) * sizeof(Data));
	for (int i = 0; i < stack->curlen; i++) fresh[i] = stack->data[i];
	stack->data = fresh;
	stack->data[stack->curlen] = data;
	stack->curlen++;
}

Data pop(SqStack* stack)
{
	Data ret;
	if (--stack->curlen >= 0) {
		ret = stack->data[stack->curlen];
	}
	else(exit(-1));
	return ret;
}

Data getLast(SqStack stack)
{
	if (stack.curlen > 0)
		return stack.data[stack.curlen - 1];
	else exit(0);
}

Data getFirst(SqStack stack){
	return stack.data[0];
}

int getLength(SqStack stack)
{
	return stack.curlen;
}

int isEmpty(SqStack stack)
{
	return stack.curlen == 0;
}

void clearStack(SqStack* stack) {
	stack->curlen = 0;
}

void destoryStack(SqStack* stack) {
	stack->curlen = 0;
	free(stack->data);
}

4.5.3 main.cpp

#include"DQueue.h"
int main() {
	DQueue dq = { };
	initStack(&dq);
	printf("前方入队列：\n");
	for (int i = 0; i < 15; i++) {
		push_front(&dq, i); printf("%d ", getLast(dq));
	}
	printf("\n后方入队列：\n");
	for (int i = 7; i < 17; i++) {
		push_back(&dq, i); printf("%d ", getFirst(dq));
	}
	printf("\n队列元素：\n");
	for (int i = 0; i < getLength(dq); i++)printf("%d ", dq.data[i]);
	printf("\n后方出队列\n");
	for (int i = 0; i < 9; i++) {
		printf("%d ", pop_back(&dq)); 
	}
	printf("\n前方出队列\n");
	for (int i = 0; i < 9; i++) {
		printf("%d ", pop_front(&dq));
	}
}

4.5.4 实现效果

在这里插入图片描述

和八哥的环球探险
关注
专栏目录
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
【问题描述】 表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 【基本要求】 以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用运算符优先关系，实现对算术四则混合运算表达式的求值。 【测试数据】 （1）能够判断表达式中的括号是否匹配，测试的表达式中括号不匹配，可以重新输入。 （2）能够处理多位整数以及浮点数。 （3）具体测试数据自定义。 【实现提示】 设置运算符栈和运算数栈辅助分析算符优先关系；在读入表达式的字符序列的同时，完成运算符和运算数（整数）的识别处理，以及相应的运算；在程序的适当位置输出运算符栈、运算数栈、输入字符和主要操作等内容。 【选做内容】 扩充运算符集，如增加乘方、单目减、赋值等运算。
表达式求值【C语言实现】数据结构实验
热门推荐
lei20172017的博客
05-04 1万+
表达式求值【C语言实现】数据结构实验 实验内容 表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 实验要求 基本要求：以字符序列的形式从键盘输入语法正确的，不含变量的整型表达式。利用教科书表 3.1 给出的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例 3.1 演示在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。 实现提示 1 设置运算符栈和运算数栈辅助分析算符优先关系。 2 在读入表达式的字符序列的同时
[数据结构实验]计算器（表达式计算-表达式树实现）
2303_77100984的博客
11-26 936
武汉理工大学数据结构实验
数据结构——栈实现综合计算器（中缀表达式）
m0_75013084的博客
05-01 551
输入一个字符串类型的表达式，例如：7*2*2-5+1-5+3-3，计算出结果。
JiSuanQi.rar_jisuanqi_栈和队列_计算器 数据结构
09-20
本话题将详细讨论基于栈和队列数据结构的计算器实现，以及如何使用Visual C++ 6.0进行编程。 首先，栈是一种后进先出（LIFO）的数据结构，它具有添加和删除元素的一端，称为栈顶。栈常用于表达式求值、递归、内存...
C和Python实现运算表达式的求值
07-12
总结来说，本项目通过C语言和Python展示了如何利用栈数据结构实现四则运算表达式的求值。C语言实现更注重底层细节和效率，而Python实现则更加简洁和灵活。这两种方法都可以帮助我们理解表达式求值的基本逻辑，同时也...
Java模拟栈和队列数据结构的基本示例讲解共4页.pdf
10-30
在实际开发中，模拟栈和队列的数据结构可以帮助我们解决各种问题，比如回溯算法、深度优先搜索（DFS）、表达式求值等。此外，Java标准库提供了`java.util.Stack`和`java.util.LinkedList`（配合`offer()`、`poll()`...
后缀表达式求值算法介绍
06-20
总结，后缀表达式求值算法是一种高效且直观的计算方法，通过使用栈数据结构简化了表达式的计算过程。理解并熟练运用这种算法，不仅有助于提升编程能力，也是深入学习计算机科学所必需的基础知识。
C++研发笔记12——C语言程序设计初阶学习笔记10
Lbs_gemini0603的博客
11-09 583
C++研发笔记12——C语言程序设计初阶学习笔记10
数据结构（1）
m0_71616132的博客
11-09 645
数据结构
数据结构-图的概念
dametime_的博客
11-09 208
修路问题将各个村庄相连,由于经费有限,只能选择将各个村庄联通为先。不存在空图现象,顶点集不能为空,边集可以为空。对于一个生成树,他有n个节点就有n-1条边。研究链接一个顶点的边有多少条非常有意义。将村庄图生成树或生成森林,选择最有路线。子图必须联通,尽可能多的边和结点。有向图的入度=出度,度=边数。给每条边赋权值解决相关问题。无向图的度=边的二倍。
C语言第十一周课——函数的调用
qq_58156721的博客
11-12 135
学习函数的调用:通过调用函数来实现二分法。通过调用函数来实现冒泡法。
数据结构：时间复杂度&空间复杂度
小黄鸭的博客
11-09 927
因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。
数据结构合并两个有序链表
weixin_60489641的博客
11-09 239
循环条件为list1与list2均不为null，开始比较list1和list2中的大小，如果是最小值将其放入nextHead的数组中，然后list1走到下一个节点继续与list2匹配，每次都将最小值或相等值放入合并的链表中。这里我们可以创建一个新的对象作为合并后的新链表newHead，而NewHead.next就是我们要返回的头部的位置。在创建一个对象来获取nextHead.next下一个节点来作为我们新链表的起始位置防止我们的头部位置找不到。然后将list2的目标节点放入nextHead.next中。
希尔排序（C语言）
最新发布
N_N12的博客
11-12 421
希尔排序是在直接插入排序的基础上演变的1.先选定一个小于n的整数gap作为间隔（一般gap = n / 3 + 1），然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。它将一组数组分为了gap组，一组中每个元素的间隔为gap。2.当gap的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。图片讲解将上述同一颜色相连的数分为一组，一共分了gap组，一组中每个元素的间隔为gap，对同一组中的元素进行插入排序。
【数据结构 | C++】字符串关键字的散列映射
等风来
11-12 233
例如将字符串AZDEG插入长度为1009的散列表中，我们首先将26个大写英文字母顺序映射到整数0~25；再通过移位将其映射为3×32^2+4×32+6=3206；然后根据表长得到3206%1009=179，即是该字符串的散列映射位置。给定一系列由大写英文字母组成的字符串关键字和素数P，用移位法定义的散列函数H(Key)将关键字Key中的最后3个字符映射为整数，每个字符占5位；再用除留余数法将整数映射到长度为P的散列表中。发生冲突时请用平方探测法解决。
自适应数据结构、自适应哈希表 (Adaptive Hash Table)详细介绍
m0_61840987的博客
11-12 540
自适应数据结构、自适应哈希表 (Adaptive Hash Table)详细介绍
Java的六大排序
Yaml4的博客
11-12 497
先创建左右两个临时数组来存储左右两部分已排序的数组，然后通过比较将较小的元素依次放回原数组，最后将剩余的元素也放回原数组。通过一趟排序将待排序的数据分割成两部分，其中一部分的所有元素都比基准元素小，另一部分的所有元素都比基准元素大。采用分治策略，将待排序序列分成两部分，分别对这两部分进行排序，然后将排序好的两部分合并成一个有序序列。，如果是，则将数组分成左右两部分，分别对左右两部分进行归并排序，然后再将两部分已排序的数组合并。把待排序的元素插入到已经排序好的部分序列中的合适位置，使得插入后的序列仍然有序。
C语言第九周课——经典算法
qq_58156721的博客
11-12 857
C语言经典例题对于外层循环遍历到的每一个整数，内层循环用于具体检查该数是否能被 2 到它自身减 1 之间的数整除。在实际应用中，如果要判断更大范围的数是否为素数，通常会采用更高效的算法，比如埃拉托斯特尼筛法等，这些算法可以大大提高判断素数的效率。总体而言，这段代码实现了一个基本的二分查找功能，但需要注意修正输出提示信息时的拼写错误以确保代码的正确性。，由于数组是降序排列的，所以目标元素应该在当前中间元素的左边，因此将。是要判断的数的范围，在本程序中是 100）。，用于存储用户从控制台输入的要查找的目标数字。
数据结构与算法解析：栈&队列深度解析
"数据结构与算法--栈&队列 很好的哦 欢迎下载" 在计算机科学中，数据结构和算法是编程的基础，而栈和队列是两种最基本且重要的数据结构。本资料深入讲解了这两者的核心概念及其应用。 栈（Stack）是一种特殊类型的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值