表达式构建二叉树(中缀,前缀,后缀)

// TheRealBinaryTreeOfMine.cpp : 定义控制台应用程序的入口点。

//

#include"stdafx.h"

#include

#include

#include

#include

#include

using namespace std;

class BinaryNode{

public:

char date;

BinaryNode * leftchild;

BinaryNode * rightchild;

BinaryNode(){

date = 0;

leftchild = NULL;

rightchild = NULL;

}

BinaryNode(char ch){

date = ch;

leftchild = NULL;

rightchild = NULL;

}

};

int first_or_last(char a, char b); //判断两个运算符的优先级；

bool isOP(char ch); //判断该字符是否属于操作符；BinaryNode* Build_BinaryTree(BinaryNode* &BT, string str);//根据中缀表达式构建一颗二叉树；

void Last(BinaryNode *bt); //后序遍历二叉树（递归）；

void First(BinaryNode *bt); //先序遍历二叉树（递归）；

void Inn(BinaryNode *bt); //中序遍历二叉树（递归）；

string Exp_turn(string s); //后缀表达式转换成中缀表达式；

string Exp_turn_and_turn(string s); //前缀表达式转换为中缀表达式；

int choice(char c, char d); //判断表达式属于什么类型的表达式（中缀，后缀，前缀）；

void Print(BinaryNode *bt); //打印二叉树（层序遍历，层层打印二叉树）；int first_or_last(char a, char b){

if (a == '/' || a == '*'){

if (b == '+' || b == '-')

return 1;

if (b == '/' || b == '*')

return 0;

else

return 0;

}

if (a == '+' || a == '-'){

if (b == '+' || b == '-')

return 0;

if (b == '/' || b == '*')

return 0;

else

return 0;

}

else

return 0;

}

bool isOP(char ch)

{

string OP = { '+', '-', '*', '/', '(', ')' };

for (int i = 0; i < 6; i++){

if (ch == OP[i])

return true;

}

return false;

}

BinaryNode* Build_BinaryTree(BinaryNode* &BT, string str){ queue aQ;

BinaryNode * root = BT;

if (str[0] == '('){

root = new BinaryNode(str[2]);

BT = new BinaryNode(str[1]);

BinaryNode *R = root;

aQ.push(BT);

int j = 3;

while (str[j] != '\0')

{

if (!isOP(str[j]))

{

BT = new BinaryNode(str[j]);

aQ.push(BT);

j++;

}

else

{

if (str[j] == ')' || str[j] == '(')

{

}

else

{

BT = new BinaryNode(str[j]);

root->leftchild = aQ.front();

//cout << root->leftchild->date;

root->rightchild = BT;

//cout << root->rightchild->date;

aQ.pop();

root = BT;

}

j++;

}

}

root->leftchild = aQ.front();

//cout << root->leftchild->date;

aQ.pop();

root->rightchild = aQ.front();

//cout << root->rightchild->date;

aQ.pop();

return R;

}

else{

root = new BinaryNode(str[1]);

BT = new BinaryNode(str[0]);

BinaryNode *R = root;

aQ.push(BT);

int j = 2;

while (str[j] != '\0')

{

if (!isOP(str[j]))

{

BT = new BinaryNode(str[j]);

aQ.push(BT);

j++;

}

else

{

if (str[j] == '(' || str[j] == ')')

{

}

else

{

BT = new BinaryNode(str[j]);

root->leftchild = aQ.front();

//cout << root->leftchild->date;

root->rightchild = BT;

//cout << root->rightchild->date;

aQ.pop();

root = BT;

}

j++;

}

}

root->leftchild = aQ.front();

//cout << root->leftchild->date;

aQ.pop();

root->rightchild = aQ.front();

//cout << root->rightchild->date;

aQ.pop();

return R;

}

}//中缀表达式构建了二叉树函数（消除了‘（’和‘）’）

void Last(BinaryNode *bt){

if (bt){

Last(bt->leftchild);

Last(bt->rightchild);

cout << bt->date;

}

}//后序遍历函数

void First(BinaryNode *bt){

if (bt){

cout << bt->date;

First(bt->leftchild);

First(bt->rightchild);

}

}//先序遍历函数

void Inn(BinaryNode *bt){

if (bt){

Inn(bt->leftchild);

cout << bt->date;

if (bt->rightchild)

{

if (isOP(bt->rightchild->date) && first_or_last(bt->date, bt->rightchild->date) == 1){ cout << "(";

Inn(bt->rightchild);

cout << ")"; //考虑root与root->leftchild操作符的优先级，如果root 的优先级较大则需要添加小括号；

}

else

Inn(bt->rightchild);

}

}

}

string Exp_turn(string s){

queue bQ;

stack bS;

int k = 0;

while (s[k] != '\0'){

if (!isOP(s[k])){

bQ.push(s[k]);

}

else

{

bS.push(s[k]);

}

k++;

} //实现了数字与操作符的分离

char ss[30];

int g = 0;

while (!bQ.empty())

{

ss[g] = bQ.front();

bQ.pop();

g++;

if (!bS.empty()){

ss[g] = bS.top();

bS.pop();

g++;

}

}

ss[g] = '\0';

return ss;

} //实现了后缀表达式转换成中缀表达式；string Exp_turn_and_turn(string s){

queue bOP;

queue bNum;

int k = 0;

while (s[k] != '\0'){

if (!isOP(s[k])){

bNum.push(s[k]);

}

else

{

bOP.push(s[k]);

}

k++;

} //实现了数字与操作符的分离char ss[30];

int g = 0;

while (!bNum.empty())

{

ss[g] = bNum.front();

bNum.pop();

g++;

if (!bOP.empty()){

ss[g] = bOP.front();

bOP.pop();

g++;

}

}

ss[g] = '\0';

return ss;

} //实现了前缀表达式转换为中缀表达式；void Print(BinaryNode *bt){

cout << endl << endl;

queue qQ;

char strstr[30];

int t = 0;

if (bt){

qQ.push(bt);

}

while (!qQ.empty()){

bt = qQ.front();

strstr[t] = bt->date;

t++;

qQ.pop();

if (bt->leftchild != NULL)

qQ.push(bt->leftchild);

if (bt->rightchild != NULL)

qQ.push(bt->rightchild);

} //采用非递归的方法层序遍历二叉树，并将序列记

录在一个数组当中，元素个数为t个

strstr[t] = '\0';

int x = 10, y = 5;;

for (int m = 0; m < x; m++){

cout << ' ';

}

cout << strstr[0] << endl;

int e = 1;

for (int n = 0; n < log2(t + 1); n++){ //此处log2(t+1)是计算该二叉树的深度

for (int v = 0; v < x - y; v++){

cout << ' ';

}

cout << strstr[e];

e++;

int z = 0;

for (z = 0; z < 10; z++){

cout << ' ';

}

cout << strstr[e];

e++;

x = x + y;

cout << endl;

}

}

int choice(char c, char d){

if (isOP(c))

return 1;

if (!isOP(c) && !isOP(d))

return 2;

if (!isOP(c) && isOP(d))

return 3;

else

return 0;

}

int_tmain(int argc, _TCHAR* argv[])

{

BinaryNode *BTree, *R;

string s;

cout << "请输入一个表达式：" << endl;

cin >> s;

string ss;

int temp;

if (s[0] == '(')

temp = choice(s[1], s[2]);

else

temp = choice(s[0], s[1]);

switch (temp)

{

case 1:{

ss = Exp_turn_and_turn(s);

R = Build_BinaryTree(BTree, ss);//构建一颗二叉树；

cout << "前缀表达式，后缀表达式，中缀表达式分别为：" << endl << endl;

First(R);//前序遍历；

cout << endl;

Last(R);//后序遍历；

cout << endl;

Inn(R);//中序遍历（考虑了小括号）

cout << endl;

cout << endl << "二叉树树形打印" << endl;

Print(R);

break;

}

case 2:{

ss = Exp_turn(s);

R = Build_BinaryTree(BTree, ss);//构建一颗二叉树；

cout << "前缀表达式，后缀表达式，中缀表达式分别为：" << endl;

First(R);//前序遍历；

cout << endl;

Last(R);//后序遍历；

cout << endl;

Inn(R);//中序遍历（考虑了小括号）

cout << endl;

cout << endl << "二叉树树形打印" << endl;

Print(R);

break;

}

case 3:{

ss = s;

R = Build_BinaryTree(BTree, ss);//构建一颗二叉树；

cout << "前缀表达式，后缀表达式，中缀表达式分别为：" << endl;

First(R);//前序遍历；

cout << endl;

Last(R);//后序遍历；

cout << endl;

Inn(R);//中序遍历（考虑了小括号）

cout << endl;

cout << endl << "二叉树树形打印" << endl;

Print(R);

break;

}

default:

break;

}

system("PAUSE");

return 0;

}