算术表达式转换为以二叉树的结构存储

#include <iostream>
#include <malloc.h>

using namespace std;

typedef struct BiTNode
{
    char data;
    BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

/**
afa:指向表达式字符串的指针
s:为要装换的表达式字符串的起始位置
e:为要装换的表达式字符串的结束位置的后一位
local_r:记录当前要转化的表达式生成二叉树的根节点操作符的位置
flag:记录是否是当前搜索在括号里面
m_m_p:记录当前表达式中括号外面最右端的*、/、^位置
a_s_p:记录当前表达式中括号外面最右端的+、-位置
**/
BiTree afaToBiTree(char *afa, int s, int e)
{
    //如果只有一个数，那就是叶子节点
    if(e-s==1)
    {
        BiTree bn = (BiTree)malloc(sizeof(BiTNode));
        bn->data = afa[s];
        bn->lchild = NULL;
        bn->rchild = NULL;
       // cout << "aaa";
        return bn;
    }

    int local_r = 0;
    int flag = 0;
    int m_m_p = 0;
    int a_s_p = 0;
    for(int i = s; i < e; i++)
    {
        if(afa[i] == '(')
        {
            flag++;
        }
        else if(afa[i] == ')')
        {
            flag--;
        }

        if(flag == 0)
        {
            if(afa[i] == '*' || afa[i] == '/' || afa[i] == '^')
            {
                m_m_p = i;
            }
            else if(afa[i] == '+' || afa[i] == '-')
            {
                a_s_p = i;
            }
        }
    }

    if((m_m_p == 0) && (a_s_p == 0))
    {
        //如果整式整个有括号，即括号外面没有操作符，则去掉括号找二叉树
        afaToBiTree(afa, s+1, e-1);
    }
    else
    {
        //如果有+货-，则根节点为最右端的+或-，否则为最右端的*或/
        if(a_s_p > 0)
        {
            local_r = a_s_p;
        }
        else if(m_m_p > 0)
        {
            local_r = m_m_p;
        }

        //确定根节点和根节点的左右孩子
        BiTree b = (BiTree)malloc(sizeof(BiTNode));
        b->data = afa[local_r];
        b->lchild = afaToBiTree(afa, s, local_r);
        b->rchild = afaToBiTree(afa, local_r+1, e);
        return b;
    }
}

void visit(BiTree T)
{
    if(T)
    {
        cout << T->data;
    }
}

void PreOrderTraveral(BiTree T)
{
    if(T)
    {
        visit(T);
        PreOrderTraveral(T->lchild);
        PreOrderTraveral(T->rchild);
    }
}

void InOrderTraverse(BiTree T)
{
    if(T)
    {
       InOrderTraverse(T->lchild);
       visit(T);
       InOrderTraverse(T->rchild);
    }
}

void PostOrderTraverse(BiTree T)
{
    if(T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        visit(T);
    }
}

int main()
{
    BiTree T = NULL;
    char str[50];
    char *afa;
    int n;
    afa = str;
    for(int i = 0; i < 50; i++)
    {
        cin >> str[i];
        if(str[i] == '#')
        {
            n = i;
            break;
        }
    }
    T = afaToBiTree(afa, 0, n);
    PreOrderTraveral(T);
    cout << endl;
    InOrderTraverse(T);
    cout << endl;
    PostOrderTraverse(T);
    return 0;
}