表达式的二叉树输入和该二叉树的遍历

实现功能：

输入一串表达式后，按照中序方式建立二叉树，并对其进行先序和后序的遍历。（输入表达式如此形式：a+b*c-d-e/f….；以#号结束。）

程序的基本思想：

输入：输入时直接输入表达式即可。（表达式中所有的符号仅为+，-，*，/，（，），）。
输出：输出时将输出二叉树的先序，中序，后序遍历结果。
判定表达式运算的运算符号的先后顺序；用 flag = 0 记作没有扫描到‘（‘，可以扫描括号外的运算符号；扫描括号外的运算符号先后顺序：+，—，大于 * ，/；如果扫描到叶子结点，直接输出，不要判断；如果括号外没有运算符号，脱掉一层括号递归循环运算；一直递归循环扫描，直到叶子结点。
遍历：递归运算遍历。
注：本程序在Linux环境下调试通过。

源代码

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#define MAXSIZE 1000
using namespace std;

typedef struct bitnode
{
    char data;
    struct bitnode *lchild;
    struct bitnode *rchild;
}bitnode, *bitree;

bitnode* creat (char *str, int s, int l)
{
    //叶子结点
    if (l - s == 1)
    {
        bitree bit;
        bit = (bitree) malloc (sizeof(bitnode));
        bit -> data = str[s];
        bit -> lchild = NULL;
        bit -> rchild = NULL;
        return bit;
    }

    //寻找最后运算的运算符
    int flag = 0, temp1 = 0, temp2 = 0, root = 0;
    for (int i = s; i < l; i ++)
    {
        if (str [i] == '(')
            flag ++;
        else if (str [i] == ')')
            flag --;

        if (flag == 0)
        {
            if (str [i] == '+' || str [i] == '-')
                temp1 = i;
            else if (str [i] == '*' || str [i] == '/')
                temp2 = i;
        }
    }

    //执行循环
    if ((temp1 == 0) && (temp2 == 0))  creat (str, s + 1, l - 1);
    else
    {       
        if (temp1 > 0)  root = temp1;
        if (temp2 > 0)  root = temp2;

        bitree bitr;
        bitr = (bitree) malloc (sizeof(bitnode));
        bitr -> data = str [root];
        bitr -> lchild = creat (str, s, root);
        bitr -> rchild = creat (str, root + 1, l);
        return bitr;
    }
}

void preordertraverse (bitnode* t)
{
    if (t)
    {
        cout << t -> data;
        preordertraverse (t -> lchild);
        preordertraverse (t -> rchild);
    }
}

void inordertraverse (bitnode* t)
{
    if (t)
    {
        inordertraverse (t -> lchild);
        cout << t -> data;
        inordertraverse (t -> rchild);
    }
}

void postordertraverse (bitnode* t)
{
    if (t)
    {
        postordertraverse (t -> rchild);
        cout << t -> data;
        postordertraverse (t -> lchild);
    }
}

int main () 
{
    char str [MAXSIZE];
    int l;
    cout << "输入表达式：" ;
    cin >> str;
    l = strlen (str);
    bitree bit;
    bit = (bitree) malloc (sizeof(bitnode));
    bit = creat (str, 0, l);
    cout << "先序遍历：" ;
    preordertraverse (bit);
    cout << endl;
    cout << "中序遍历：" ;
    inordertraverse (bit);
    cout << endl;
    cout << "后序遍历：" ;
    postordertraverse (bit);
    return 0;
}

输出结果：