算術表示式轉換為以二叉樹的結構儲存

#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;
}