利用二叉树实现表达式计算
// 本文利用二叉树实现简单的加减乘除的表达式运算：
//调用代码:
ExpressionTree ET = NULL;
U8 in_str[]="(1+(33*4))+(((4*5)+9)*7)";
ExpressionElementType exp_str[100]={0};
U32 count = ConvertExpressionString(in_str,strlen(in_str),exp_str);
ET = ExpressionTree_MakeTree(ET,exp_str,count);
U32 result = ExpressionTree_Calculate(ET);
// (1+(33*4))+(((4*5)+9)*8)
U32 ConvertExpressionString(U8* in_str,U32 count,ExpressionElementType* out_str) { U8* str = in_str; bool digits_flag = false; U8 digit_buf[10]={0}; U32 digit_len = 0; U32 exp_count = 0; for(U32 ix=0;ix<count;ix++,str++) { if(ExpressionTree_IsOperand(*str)||(*str=='\(')||(*str=='\)')) { if(digits_flag) { *out_str = atoi(digit_buf); out_str++; exp_count++; memset(digit_buf,0,sizeof(digit_buf)); digits_flag = false; digit_len = 0; } *out_str = (ExpressionElementType)*str; out_str++; exp_count++; } else { digits_flag= true; digit_buf[digit_len++] = *str; } }
str--; if(*str!='\)') { *out_str = atoi(digit_buf); out_str++; exp_count++; }
return exp_count; }
ExpressionTree.cpp：
//---------------------------------------------------------------------------
#pragma hdrstop
#include "ExpressionTree.h"
#include <stdio.h>
#include <alloc.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
//加法
ExpressionElementType Additon(ExpressionElementType left,ExpressionElementType right)
{
return (left+right);
}
//减法
ExpressionElementType Subtraction(ExpressionElementType left,ExpressionElementType right)
{
return (left-right);
}
//乘法
ExpressionElementType Multiplication(ExpressionElementType left,ExpressionElementType right)
{
return (left*right);
}
//除法
ExpressionElementType Division(ExpressionElementType left,ExpressionElementType right)
{
if(right==0)
{
return 0;
}
return (left/right);
}
//百分比
ExpressionElementType Percentage(ExpressionElementType left,ExpressionElementType right)
{
return (left*100);
}
//倒数
ExpressionElementType Reciprocal(ExpressionElementType left,ExpressionElementType right)
{
if(left==0)
{
return 0;
}
return (1/left);
}
//最小值
ExpressionElementType Min(ExpressionElementType left,ExpressionElementType right)
{
if(left < right)
{
return left;
}
return right;
}
//最大值
ExpressionElementType Max(ExpressionElementType left,ExpressionElementType right)
{
if(left < right)
{
return right;
}
return left;
}
//平均值
ExpressionElementType Average(ExpressionElementType left,ExpressionElementType right)
{
return (left+right)/2;
}
static Expression_Math_Table expression_math_table[] = {
{'+', Additon},
{'-', Subtraction},
{'*', Multiplication},
{'/', Division},
{'<', Average},
{'%', Percentage},
{'X', Reciprocal}
};
#define Math_Table_Len (sizeof(expression_math_table)/sizeof(expression_math_table[0]))
ExpressionTree ExpressionTree_MakeEmpty(ExpressionTree T)
{
if(T!=NULL)
{
ExpressionTree_MakeEmpty(T->Left);
ExpressionTree_MakeEmpty(T->Right);
free(T);
T=NULL;
}
return NULL;
}
ExpressionTree ExpressionTree_Insert(ExpressionElementType X,ExpressionTree T)
{
if(T==NULL)
{
T = (ExpressionTree)malloc( sizeof(ExpressionTreeNode));
if(T==NULL)
{
printf("Out of memory\n");
}
else
{
T->E = X;
T->Left = T->Right = NULL;
}
}
else
{
if (T->Left==NULL)
{
T->Left = ExpressionTree_Insert(X,T->Left);
}
else if (T->Right==NULL)
{
T->Right = ExpressionTree_Insert(X,T->Right);
}
else
{
printf("Has no empty child now.0x%X\n",T);
}
}
return T;
}
//Go through the tree
ExpressionTree ExpressionTree_Traversal(ExpressionTree T)
{
}
bool ExpressionTree_IsOperand(ExpressionElementType X)
{
for(U32 ix=0;ix<Math_Table_Len;ix++)
{
if(expression_math_table[ix].Operand == X )
{
return true;
}
}
return false;
}
//(a+(b*c))+(((d*e)+f)*g)
/* Binary Tree Node Graph
+
/ \
/ \
/ \
/ \
/ \
/ \
+ *
/ \ / \
a * + g
/ \ / \
b c * f
/ \
d e
*/
//Translate a string into expression tree.
//Assume that the string is valid for parsing.
//You should preprocess your string first to meet this function.
ExpressionTree ExpressionTree_MakeTree(ExpressionTree T,ExpressionElementType* Str,U32 Len)
{
ExpressionElementType* str = Str;
if(Len==0)
{
return T;
}
if(Len==1)
{
T = ExpressionTree_Insert (*str,T);
return T;
}
if(Len==3) //A Operand B
{
T = ExpressionTree_Insert (*(str+1),T);//Current Node
T = ExpressionTree_Insert (*(str),T);//Left
T = ExpressionTree_Insert (*(str+2),T);//Right
return T;
}
ExpressionElementType left_parenthesis = '(';
ExpressionElementType right_parenthesis = ')';
U32 count_left_parenthesis = 0;
U32 count_right_parenthesis = 0;
ExpressionElementType ch = 0;
for(U32 ix=0;ix<Len;ix++,str++)
{
ch = *str;
if(left_parenthesis==ch)
{
count_left_parenthesis++;
}
if(right_parenthesis==ch)
{
count_right_parenthesis++;
}
if ((count_left_parenthesis==count_right_parenthesis) && ExpressionTree_IsOperand(ch))
{ //It is like "(a+(b*c))+(((d*e)+f)*g)"
//You searched "+" in the middle
T = ExpressionTree_Insert (ch,T);//Current Node
if(*Str==left_parenthesis) //First is (
{
T->Left = ExpressionTree_MakeTree(T->Left,Str+1,ix-2);
}
else
{
T->Left= ExpressionTree_MakeTree(T->Left,Str,ix);
}
if (*(Str+ix+1)==left_parenthesis)
{
T->Right = ExpressionTree_MakeTree(T->Right,Str+ix+2,Len - ix -3);
}
else
{
T->Right = ExpressionTree_MakeTree(T->Right,Str+ix+1,Len - ix -1);
}
}
}
return T;
}
ExpressionElementType ExpressionTree_Calculate(ExpressionTree T)
{
ExpressionElementType result = (ExpressionElementType)0;
if(T==NULL)
{
return (ExpressionElementType)0;
}
if((T->Left==NULL) && (T->Right==NULL)) //No Child,It's operator
{
result = T->E;
}
else //Has child ,It's operand
{
for(U32 ix=0;ix<Math_Table_Len;ix++)
{
if(expression_math_table[ix].Operand == T->E)
{
result = expression_math_table[ix].Fun(ExpressionTree_Calculate(T->Left),ExpressionTree_Calculate(T->Right));
break;
}
}
}
return result;
}
ExpressionTree.h
//---------------------------------------------------------------------------
#ifndef ExpressionTreeH
#define ExpressionTreeH
#include "DataTypes.h"
//表达式的计算可以采用栈(数组实现)的结构来实现其计算结果功能
//(a+(b*c))+(((d*e)+f)*g)
/* Binary Tree Node Graph
+
/ \
/ \
/ \
/ \
/ \
/ \
+ *
/ \ / \
a * + g
/ \ / \
b c * f
/ \
d e
*/
typedef struct ExpressionTreeNode *PtrToExpressionNode;
typedef struct ExpressionTreeNode *ExpressionTree;
typedef unsigned int ExpressionElementType;
struct ExpressionTreeNode
{
ExpressionElementType E;
ExpressionTree Left;
ExpressionTree Right;
};
typedef ExpressionElementType (*Expression_FunPTr)(ExpressionElementType left,ExpressionElementType right);
typedef struct _Expression_Math_Table
{
ExpressionElementType Operand;
Expression_FunPTr Fun;
} Expression_Math_Table;
ExpressionTree ExpressionTree_MakeTree(ExpressionTree T,ExpressionElementType* Str,U32 Len);
ExpressionElementType ExpressionTree_Calculate(ExpressionTree T);
bool ExpressionTree_IsOperand(ExpressionElementType X);
ExpressionTree ExpressionTree_MakeEmpty(ExpressionTree T);
//---------------------------------------------------------------------------
#endif