2. 程式人生 > >演算法表示式求值演示（棧的應用）

演算法表示式求值演示（棧的應用）

阿新 • • 發佈：2018-12-16

【問題描述】 表示式計算是實現程式設計語言的基本問題之一，也是棧的應用的一個典型例子。設計一個程式，演示用算符優先法對算術表示式求值的過程。 【實現要求】 (1) 以字元序列的形式從終端輸入語法正確的、不含變數的整數表示式。利用下表給出的算符優先關係，實現對算術混合運算表示式的求值，並仿照求值中運算子棧、運算數棧、輸入字元和主要操作的變化過程。 (2) 擴充運算子集，如增加乘方、單目減、賦值等運算。 (3) 計算器的功能和模擬介面（選作）。 【測試資料】 下列表達式： 3*(7-2); 8; 1+2+3+4; 88-15; 1024/48; 1024/(48); (20+2)(6/2); 3-3-3; 8/(9-9); 2*(6+2*(3+6*(6+6))); (((6+6)*6+3)*2+6)*2; 【實現提示】

(1) 設定運算子棧和運算數棧輔助分析算符優先關係。 (2) 在讀入表示式的字元序列的同時，完成運算子和運算數（整數）的識別處理，以及相應的運算。 (3) 在識別出運算數的同時，要將其字元序列形式轉換成整數形式。 (4) 在程式的適當位置輸出運算子棧、運算數棧、輸入字元和主要操作的內容。

實現思路： 主要使用的是棧的結構。程式實現一共分為兩步：第一步，將輸入的表示式轉化為計算機方便處理的字尾表示式，；第二步，計算字尾表示式。 其中第一步，使用了兩個棧：操作符儲存棧（op）以及字尾表示式儲存棧（postexp）。而第二步，則是通過一個輔助棧，結合字尾表示式儲存棧（postexp）即主棧，分別對每個操作符以及對應得運算元進行計算，計算完成後再將其壓入主棧，最後當整個表示式計算完成後再將最後結果彈出，並輸出。 在處理單目操作符：“++”與“–”將其轉為“a”與“s”方便進行處理。 操作：

直接輸入表示式，再輸入“enter”即可得到表示式的結果，會忽略空格。

main.cpp


#include<iostream>
#include<string>
#include<stdlib.h>
#include"stack.h"
#include<Windows.h>

using namespace std;


char Precede(char a, char b) {
	int i, j;
	char pre[][10] = {
		/*運算子之間的優先順序製作成一張表格*/
		{ '>','>','<','<','<','>','<','<','<','>' },
		{ '>','>','<','<','<','>','<','<','<','>' },
		{ '>','>','>','>','<','>','<','<','<','>' },
		{ '>','>','>','>','<','>','<','<','<','>' },
		{ '<','<','<','<','<','>','<','<','<','0' },
		{ '>','>','>','>','0','=','>','>','>','>' },
		{ '>','>','>','>','<','>','>','<','<','>' },
		{ '>','>','>','>','<','>','>','>','>','>' },
		{ '>','>','>','>','<','>','>','>','>','>' },
		{ '<','<','<','<','<','0','<','<','<','=' } };
	switch (a) {
	case '+': i = 0; break;
	case '-': i = 1; break;
	case '*': i = 2; break;
	case '/': i = 3; break;
	case '(': i = 4; break;
	case ')': i = 5; break;
	case '^': i = 6; break;
	case 'a': i = 7; break;//用a代替++符號方便處理
	case 's': i = 8; break;//用s代替--符號方便處理
	case '#': i = 9; break;
	}
	switch (b) {
	case '+': j = 0; break;
	case '-': j = 1; break;
	case '*': j = 2; break;
	case '/': j = 3; break;
	case '(': j = 4; break;
	case ')': j = 5; break;
	case '^': j = 6; break;
	case '++': j = 7; break;
	case '--': j = 8; break;
	case '#': j = 9; break;
	}
	return pre[i][j];
}

int tranNum(stackL *postexp, string exp, int i)//將中綴表示式中的多位數，按照從低位到高位順序壓入postexp棧中，方便後續計算
{
	int len = 0,j;
	char expRead = exp[i];
	while (expRead <= '9'&&expRead >= '0')//獲得數符長度
	{
		//PushL(postexp, expRead);
		i++;
		expRead = exp[i];
		len++;
	}
	for (j = i-1; j >= i - len;j--)
	{
		PushL(postexp, exp[j]);
	}
	i--;			//使i恰好下次迴圈指向非數字
	PushL(postexp, '#');
	return i;
}
void tranPost(stackL *op, stackL*postexp, string exp)//將中綴表示式轉化為字尾表示式
{
	int i;
	char expRead, tempChar,preOp;
	InitStackL(op);
	InitStackL(postexp);
	PushL(op, '#');
	PushL(postexp, '#');

	for (i = 0; i < (int)exp.length(); i++)
	{
		expRead = exp[i];
		
		if (expRead == '#')				//表示式尾端
			break;
		else if (expRead == ' ')		//忽略空格
			continue;
		else if (expRead <= '9'&&expRead >= '0')	//處理運算元，傳入i，postexp，exp，返回i
		{
			i = tranNum(postexp, exp, i);
		}
		else if (expRead != '(' && expRead != ')' && expRead == exp[i + 1])//處理單目運算子（++、--）
		{
			if (expRead == '+')
				PushL(op, 'a');
			else if (expRead == '-')
				PushL(op, 's');
			else
			{
				cout << "error\n";
				break;
			}
			i++;									//使遍歷跳過自增自減符號到下一字元
		}
		else		//處理普通操作符
		{
			tempChar = GetTopL(op);
			preOp = Precede(tempChar, expRead);
			if (expRead == ')')
			{
				tempChar = PopL(op);
				while (tempChar != '(')
				{
					PushL(postexp, tempChar);
					//PushL(postexp, '#');

					tempChar = PopL(op);
				}
			}
			else if (preOp == '>')
			{
				PushL(postexp, PopL(op));
				PushL(op, expRead);
				//PushL(postexp, '#');
			}
			else if (preOp == '<')
				PushL(op, expRead);
		}
	}

	while (op->next->data != '#')
	{
		tempChar = PopL(op);
		PushL(postexp, tempChar);
	}
}

int ary(int expn)
{
	int i;
	int sum = 1;
	for (i = 0; i < expn; i++)
	{
		sum *= 10;
	}
	return sum;
}

int getValue(stackL *assistStack)//求得屬於同一數值的連續數符的值
{
	int value = 0;
	int ex = 0;
	char charValue;
	charValue = PopL(assistStack);
	while (charValue != '#')
	{
		value += (charValue - 48)*ary(ex);
		ex++;
		charValue = PopL(assistStack);
	}
	return value;
}

void pushBack(stackL *postexp, int valueBack)//將計算出來的int值化作字元，並從低位到高位壓入主棧中
{
	int i = 0;
	char valueChar;
	if (valueBack == 0)
		PushL(postexp, '0');
	while (valueBack != 0)
	{
		valueChar= (valueBack % 10)+48;
		PushL(postexp, valueChar);
		valueBack = valueBack / 10;
	}
	PushL(postexp, '#');
}

int power(int value, int expn)
{
	int result = 1;
	for (int i = 0; i < expn; i++)
	{
		result *= value;
	}
	return result;
}
int partCalu(stackL *postexp,stackL *assistStack )//計算小段式的值,此時兩個運算元分別在兩個棧中，運算元在輔助棧裡
{
	int value_1, value_2, value_3;
	char opera;
	PushL(assistStack, PopL(postexp));
	while (GetTopL(postexp) <= '9'&&GetTopL(postexp) >= '0')//使兩個運算元和運算子都在輔助棧中，方便運算元的還原
	{
		PushL(assistStack, PopL(postexp));
	}

	value_1 = getValue(assistStack);
	value_2 = getValue(assistStack);
	opera = PopL(assistStack);

	switch (opera)
	{
	case '+':
		value_3 = value_1 + value_2;
		break;
	case '-':
		value_3 = value_1 - value_2;
		break;
	case '*':
		value_3 = value_1 * value_2;
		break;
	case '/':
		if (value_2 == 0)
		{
			cout << "error:除數為0" << endl;
			return 0;
		}
		else
		value_3 = value_1 / value_2;
		break;
	case'^':
		value_3 = power(value_1, value_2);
	default:
		break;
	}
	if (assistStack->next == NULL && postexp->next == NULL)
	{
		cout << value_2;
		return 0;
	}
	else if (assistStack->next == NULL && postexp->next->next == NULL)//結束條件
	{
		cout << value_3;
		return 0;
	}
	pushBack(postexp, value_3);//將部分求值結果重新壓入主棧

	if (GetTopL(assistStack) <= '9'&&GetTopL(assistStack) >= '0')//再次滿足部分求值條件
		partCalu(postexp, assistStack);
}
int caluValue(stackL *postexp)
{
	int control = 1;
	int value = 0;
	stackL *assistStack;
	char postRead,opera;
	assistStack = (stackL*)malloc(sizeof(stackL));
	InitStackL(assistStack);

	postRead = GetTopL(postexp);
	while (postexp->next != NULL)
	{
		/*主棧棧頂為#時進行是否部分求值檢測，
		如果輔助棧頂為數符的話，則進行部分求值，求值後將值繼續壓入主棧，
		壓入時注意低位先壓入，這樣就可以在連續求值時進行遞迴*/
		if (postRead == '#'&&assistStack->next!=NULL)
		{
			if (GetTopL(assistStack) <= '9'&&GetTopL(assistStack) >= '0')
			{
				control =partCalu(postexp, assistStack);
				if (control == 0)
					return 0;
			}
				
			else if(GetTopL(assistStack) > '9'|| GetTopL(assistStack) < '0')
				PushL(assistStack, PopL(postexp));
		}
		else if (postRead == 'a'||postRead == 's')
		{
			opera=PopL(postexp);
			if (GetTopL(postexp) != '#')
			{
				cout << "單目運算子運用錯誤，應放在數字後" << endl;
				exit(0);
			}
			else
			{
				PushL(assistStack,PopL(postexp));
				while (GetTopL(postexp) <= '9'&&GetTopL(postexp) >= '0')//將數符彈出主棧 並壓入輔助棧中
				{
					PushL(assistStack, PopL(postexp));
				}
				if (opera == 'a')
					pushBack(postexp, getValue(assistStack) + 1);
				else if (opera == 's')
					pushBack(postexp, getValue(assistStack) - 1);
			}
		}
		else
			PushL(assistStack, PopL(postexp));
		postRead = GetTopL(postexp);
	}
}

int main()
{
	while (1)
	{
		string express;
		cout << "please enter the expression statement,and end with '#'" << endl;
		cin >> express;

		stackL *op, *postexp;
		op = (stackL*)malloc(sizeof(stackL));	// 操作符棧
		postexp = (stackL*)malloc(sizeof(stackL));	//字尾表示式棧

		tranPost(op, postexp, express);	//將輸入的中綴表示式轉化為字尾表示式
		cout << express << " = ";
		caluValue(postexp);	//計算字尾表示式的值
		cout << "\n\n";
		free(op);
		free(postexp);
	}
}

stack.h

#include<stdlib.h>
#include<iostream>

using namespace std;

typedef char Elemtype;

typedef struct LinkStack
{
	Elemtype data;
	struct LinkStack *next;
}stackL;

//初始化
void InitStackL(stackL *lst)
{
	lst->next = NULL;
}
//判斷是否為空，為空則返回1
int StackLEmpty(stackL *lst)
{
	return (lst->next == NULL);
}

//壓入
void PushL(stackL *lst, Elemtype x)
{
	stackL *p;
	p = (stackL*)malloc(sizeof(stackL));
	p->next = lst->next;
	p->data = x;
	lst->next = p;
}

//彈出
Elemtype PopL(stackL* lst)
{
	stackL *toFree;
	if (lst->next == NULL);
		//cout << "the stack is empty\n";
	else
	{
		Elemtype x;
		x = (lst->next)->data;
		toFree = lst->next;
		lst->next = (lst->next)->next;
		free(toFree);
		return x;
	}
	return 0;
}

//獲取棧頂元素
Elemtype GetTopL(stackL* lst)
{
	if (lst->next == NULL);
		//cout << "the stack is empty\n";
	else
	{
		Elemtype x;
		x = lst->next->data;
		return x;
	}
	return 0;
}

相關推薦

演算法表示式求值演示（棧的應用）

【問題描述】 表示式計算是實現程式設計語言的基本問題之一，也是棧的應用的一個典型例子。設計一個程式，演示用算符優先法對算術表示式求值的過程。 【實現要求】 (1) 以字元序列的形式從終端輸入語法正確的、不含變數的整數表示式。利用下表給出的算符優先關係，實現對算術

棧的應用——Dijkstra雙棧演算法表示式求值演算法

一、演算法原理： 表示式由括號、運算符合運算元（數字）組成。我們根據以下4種情況從左到右逐個將這些實數送入棧處理： 1、將運算元壓入運算元棧； 2、將運算子壓入運算子棧； 3、忽略左括號； 4、在遇到右括號時，彈出一個運算子，彈出所需數量的運算元，並將運算子和運算元的運算結

表示式求值運算（逆波蘭式）

逆波蘭式：中綴表示式，字尾表示式等內容可百度檢視。運算表示式  2+3*(1+2)-6/3開兩個棧，一個存數字，一個存符號。當 遇到這種情況1：需要先計算後面的內容，再回來計算前面的運算讓符號進棧暫時儲

邏輯迴歸和樸素貝葉斯演算法實現二值分類（matlab程式碼）

資料簡介：共有306組資料，每組資料有三個屬性(x1,x2,x2)，屬於0類或者1類。 資料序號末尾為1的是測試集，有31組；其他的作為訓練集，有275組。 clear clc load('

（棧應用）每日溫度

題目描述 Given a list of daily temperatures T, return a list such that, for each day in the input, tells you how many days you would have to wait un

Uva 514 Rails（棧應用）

Uva 514 Rails 題意：  1-n編號的車從A駛入車站然後出站到B 問能否按照你輸入的順序輸出  （進入中轉站Station可以暫時停在裡面 要滿足後進先出）簡單的棧應用 #inclu

演算法學習-拓撲排序（佇列應用）

題目 對一個有向無環圖G進行拓撲排序，是將G中所有定點排成線性序列，使得途中任意一堆頂點u、v，若邊（u，v）∈E（G），則線上性序列中u出現在v之前。 分析 一個節點沒有節點指向（即入

“棧”的典型應用—表示式求值（C語言實現）【轉】

我們都知道算術四則運算的運算規則是： 先乘除，後加減。 從左到右計算 先算括號內，再算括號外 表示式組成 任何一個表示式都有運算元、運算子和界定符組成。 運算元即可以是常量，也可以是被說明為變數或常量的識別符號。 運算子可以分為算術運算，關係運算和邏輯運

資料結構之-鏈式棧及其常見應用（進位制轉換、括號匹配、行編輯程式、表示式求值等）

1、棧的概念 棧（stack）又名堆疊，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧

中綴表示式轉字尾表示式求值（棧的應用）

咱們熟悉的四則運算表示式，中綴表示式，例如 （12+3）*2-6/2 利用堆疊的方法把中綴表示式轉換成保值的字尾表示式（又稱逆波蘭表示法），並最終變為計算機可以直接執行的指令，得到表示式的值 挺簡單的不假，也好理解，但就是一直無緣無故的卡著，卡的蛋疼…… 也不能說完全的無

【資料結構】棧的應用---四則運算表示式求值（中綴表示式與字尾表示式轉換）

用計算機實現帶括號的四則運算的方式。 這裡的困難在於乘除運算的優先順序高於加減運算，並且加入了括號，使得問題變得更加困難。 20世紀50年代，波蘭邏輯學家想到了一種不需要括號的字尾表達法，我們也把它稱為逆波蘭表示。 比如：9+(3-1)*3+10/2，如果

資料結構——棧的應用（表示式求值）（C語言）

char Precede(char t1, char t2)函式用於輸出t1,t2兩個運算子的優先順序（t1為先出現的運算子（已經壓入棧OPTR中），t2為後出現的運算子） char Precede(char t1, char t2){ int

棧及其應用（表示式求值、括號匹配）

一、棧（stack） 1、棧的特點   棧(Stack)是一種線性儲存結構，它具有如下特點： 【Note】： （1）棧中的資料元素遵守”先進後出”(First In Last Out)的原則，簡

棧---定義、應用（遞迴、字尾表示式實現數學表示式求值）

一、定義 棧是限定僅在表尾進行插入和刪除操作的線性表。因此，棧的表尾端稱為棧頂；表頭端稱為棧底。不含任何資料元素的棧稱為空棧。棧又稱為後進先出(Last In First Out)的線性表，簡稱LIF0結構。 理解棧的定義需要注意：首先它是一個線性表，也即棧

[資料結構與演算法] 5，棧的應用-四則運算表示式求值

1，字尾(逆波蘭)表示法定義 計算器可以幫忙計算一些簡單的加減乘除，但是如果遇到一些比較複雜的，比如說有大中小括號的四則運算，那麼一些普通的計算器就無法實現運算了，但是觀察發現，所有的括號都是成對出

算術表示式求值（棧的應用）

算術表示式求值的難點 運算子有優先規則 對於一般的算術表示式a*b+(c-d/e)*f來說，如果要對它求值，在計算機取到×的時候，不能直接運算，需要繼續往後取值，找是否有比×運算級高的符號，沒有的話才能運算。 運算子的運算元是否能直接操作 而且還

棧的應用--四則運算表示式求值（java語言）

棧的應用–四則運算表示式求值（java語言） 前言 在複習資料結構的過程中，採用單鏈表實現了棧Stack，具體功能有如下幾個功能：判斷其是否為空棧、輸出棧的長度、入棧、出棧並且實現Iterable藉口，可以採用Iterator遍歷棧。在測試了棧之後，覺得應該

棧的運用（算數表示式求值的算符優先演算法 十以內簡單版）

假定運算子有加(+)，減(-)，乘(*)，除(/))，運算元限制為一位數，圓括號看作分界符。 中綴表示式 a*b+c a+b*c a+(b*c+d)/e 字尾表示式（RPN) ab

棧：棧及表示式求值與迷宮問題的簡單應用

棧 棧是一種進出受限的線性表。即僅可在一端進出資料，於是具有FILO（first in last out 先進後出）這種特點。 適合於各種需要回退到上一狀態的應用場景。並且通過對進出規則的進一步控制，將優先順序轉化為出現位置的先後順序上。 ADT Stack{ 　　資料物件：同一資料

java棧應用之表示式求值

原始碼的github地址,可以下載到本地執行 package stack.demo; import java.io.IOException; import java.util.Scanner; import java.util.Stack; /** * 表示式求值 算符優先