這次是某人的課程作業,題目不難,但是很複雜

原題如下

  以字元序列的形式從鍵盤輸入不含變數的整數算術四則表示式（可以有小括號）；
  檢查表示式的正確性
  將其轉換為二叉樹的儲存表示；
  通過後序遍歷得到其後綴表示式序列，輸出該序列；
  利用字尾表示式進行求值運算，輸出求值結果

原本按照我的思路,先求字尾表示式在求值與生成樹,不過既然題目這麼說了,就不得不按照題目要求去做......

1.表示式的正確性

原本的思路是做正則表示式,在利用包或者是自己寫一個自動機去實現,不過發現這裡面的正則表示式有一點小複雜.後來在網上找到了遞迴下降分析法的思路,就正好最近也在寫編譯原理的題目,剛好把詞法分析器辦過來用.

2.二叉樹生成

二叉樹的生成和字尾表示式的求值其實是很相似的,都是利用兩個棧,反覆比較兩個棧的內容,進行求值,只是一個是顯示數值,另外一個這是構造節點.在資料結構的書中講述過後綴表示式的演算法,在這裡就不贅述了

最後提供

#include <iostream>
#include <vector>
#include <string>
#include <utility>
#include<stack>
using namespace std;

enum Type
{
	Other, Add, Sub, Mul, Div, Num, LetfBra, RightBra
};

typedef pair<string, Type> Tocken;

vector<Tocken> word;

struct Node
{
	string oper;//運算元或運算子   
	Node *left;//左子樹   
	Node *right;//右子樹   
};

int idx = Other;
Type sym;
int err = 0; // 錯誤

void E();
void E1();
void T();
void T1();
void F();
void PutIn(string& expr);

bool isOper(char op)
{
	return op == '+' || op == '-' || op == '*' || op == '/' || op == '(' || op == ')';
}

//求運算子的優先順序   
int getOperPri(char op)
{
	switch (op)
	{
	case '(':
		return 1; break;
	case '+':
	case '-':
		return 2; break;
	case '*':
	case '/':
		return 3; break;
	default:
		return 0;
	}
}

//銷燬二叉樹   
void freeTree(Node*& p)
{
	if (p->left != NULL)
		freeTree(p->left);
	if (p->right != NULL)
		freeTree(p->right);
	delete(p);
}

//表示式生成二叉樹   
void generateTree(Node*& p, vector<Tocken> WordArray)
{
	stack <char> operStack;
	stack <Node*> dataStack;
	char c;
	
	vector<Tocken>::iterator tmpite = WordArray.begin();
	while (tmpite != WordArray.end() || operStack.size() != 0)
	{
		if (tmpite != WordArray.end() && tmpite->second == 5)//是運算數字，則進運算元的棧   
		{
			p = new Node;
			p->oper = tmpite->first;
			p->left = NULL;
			p->right = NULL;
			dataStack.push(p);
			tmpite++;

		}
		else
		{
			if (tmpite != WordArray.end()){
				switch (tmpite->first[0])
				{
				case '('://進棧   
					operStack.push('(');
					tmpite++;
					break;
				case ')'://脫括號   
					while (true)
					{
						c = operStack.top();
						operStack.pop();
						if (c == '(')
						{
							break;
						}
						p = new Node;
						p->oper = c;
						p->left = NULL;
						p->right = NULL;
						if (dataStack.size())
						{
							p->right = dataStack.top();
							dataStack.pop();
						}
						if (dataStack.size())
						{
							p->left = dataStack.top();
							dataStack.pop();
						}
						dataStack.push(p);
					}
					tmpite++;
					break;
				default:
					if (operStack.size() == 0 || getOperPri(operStack.top()) < getOperPri(tmpite->first[0]))
					{//進棧
						operStack.push(tmpite->first[0]);

						tmpite++;
					}
					else
					{//出棧   
						p = new Node();
						p->oper = operStack.top();
						p->left = NULL;
						p->right = NULL;
						if (dataStack.size())
						{
							p->right = dataStack.top();
							dataStack.pop();
						}
						if (dataStack.size())
						{
							p->left = dataStack.top();
							dataStack.pop();
						}
						dataStack.push(p);
						operStack.pop();
					}
					break;
				}
			}

			else{
				p = new Node();
				p->oper = operStack.top();
				p->left = NULL;
				p->right = NULL;
				if (dataStack.size())
				{
					p->right = dataStack.top();
					dataStack.pop();
				}
				if (dataStack.size())
				{
					p->left = dataStack.top();
					dataStack.pop();
				}
				dataStack.push(p);
				operStack.pop();
			}
		}
	}
	p = dataStack.top();
	dataStack.pop();
}

void PutIn(string& expr)
{
	cout << "輸入轉化的表示式\n";
	cin >> expr;
}

bool AfterTraversal(Node* p, vector<string>& After)
{
	if (NULL == p){
		return false;
	}
	AfterTraversal(p->left, After);
	AfterTraversal(p->right, After);
	cout << p->oper << " ";
	After.push_back(p->oper);
	return true;

}

/*--------------------------------詞法分析----------------------------*/
bool word_analysis(vector<Tocken>& word, const string expr)
{
	for (int i = 0; i<expr.length(); ++i)
	{
		// 如果是 + - * / ( )
		if (expr[i] == '(' || expr[i] == ')' || expr[i] == '+'
			|| expr[i] == '-' || expr[i] == '*' || expr[i] == '/')
		{
			string tmp;
			tmp.push_back(expr[i]);
			switch (expr[i])
			{
			case '+':
				word.push_back(make_pair(tmp, Add));
				break;
			case '-':
				word.push_back(make_pair(tmp, Sub));
				break;
			case '*':
				word.push_back(make_pair(tmp, Mul));
				break;
			case '/':
				word.push_back(make_pair(tmp, Div));
				break;
			case '(':
				word.push_back(make_pair(tmp, LetfBra));
				break;
			case ')':
				word.push_back(make_pair(tmp, RightBra));
				break;
			}
		}
		// 如果是數字開頭
		else if (expr[i] >= '1' && expr[i] <= '9')
		{
			string tmp;
			while (expr[i] >= '0' && expr[i] <= '9')
			{
				tmp.push_back(expr[i]);
				++i;
			}

			word.push_back(make_pair(tmp, Num));
			--i;
		}
		else
		{
			return false;
		}
	}
	return true;
}
/*--------------------------------語法分析----------------------------*/
// 讀下一單詞的種別編碼
void Next()
{
	if (idx < word.size())
		sym = word[idx++].second;
	else
		sym = Other;
}

// E → TE' 
void E()
{
	T();
	E1();
}

// E' → +TE' | -TE' | ε 
void E1()
{
	if (sym == 1)
	{
		Next();
		T();
		E1();
	}
	else if (sym == 2)
	{
		Next();
		T();
		E1();
	}
	else if (sym != 7 && sym != 0)
	{
		err = -1;
	}
}

// T → FT' 
void T()
{
	F();
	T1();
}

// T' → *FT' | /FT' | ε 
void T1()
{
	if (sym == 3)
	{
		Next();
		F();
		T1();
	}
	else if (sym == 4)
	{
		Next();
		F();
		T1();
	}
	else if (sym != 1 && sym != 2 && sym != 7 && sym != 0)
	{
		err = -1;
	}
}

// F → (E) | d
void F()
{
	if (sym == 5)
	{
		Next();
	}
	else if (sym == 6)
	{
		Next();
		E();
		if (sym == 7)
		{
			Next();
		}
		else
		{
			err = -1;
		}
	}
	else
	{
		err = -1;
	}
}


int prior(char c)
{
	switch (c)
	{
	case '+':
	case '-':
		return 1;
	case '*':
	case '/':
		return 2;
	default:
		return 0;
	}
}

bool isOperator(char c)
{
	switch (c)
	{
	case '+':
	case '-':
	case '*':
	case '/':
		return true;
	default:
		return false;
	}
}


// 從棧中連續彈出兩個運算元
void popTwoNumbers(stack<int>& s, int& first, int& second)
{
	first = s.top();
	s.pop();
	second = s.top();
	s.pop();
}

// 計算字尾表示式的值
int expCalculate(const vector<string>& postfix)
{
	int first, second;
	stack<int> s;
	for (int i = 0; i<postfix.size(); ++i)
	{
		string c = postfix[i];
		switch (c[0])
		{
		case '+':
			popTwoNumbers(s, first, second);
			s.push(second + first);
			break;
		case '-':
			popTwoNumbers(s, first, second);
			s.push(second - first);
			break;
		case '*':
			popTwoNumbers(s, first, second);
			s.push(second*first);
			break;
		case '/':
			popTwoNumbers(s, first, second);
			s.push(second / first);
			break;
		default:
			s.push(atoi(c.c_str()));
			break;
		}
	}
	int result = s.top();
	s.pop();
	return result;
}


int main()
{
	string expr;
	PutIn(expr);
	vector<string> After;
	Node* p = new Node();
	if (!word_analysis(word, expr)){
		cout << "輸入一個錯誤的表示式" << endl;
	}

	else
	{
		Next();
		E();
		if (sym == 0 && err == 0){  // 注意要判斷兩個條件
			cout << "表示式正確" << endl;
			
			generateTree(p,word);
			AfterTraversal(p, After);
			cout << endl;
			cout << "值為:"<< expCalculate(After);
		}

		else
			cout << "輸入錯誤的表示式" << endl;
	}



	return 0;
}