二叉樹計算中綴表達式

         二叉樹計算中綴表達式，暫時不支持括號，直接以字符串形式輸入。

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>

typedef struct tagbintree
{
 char op;
 char level; /* 記錄括號 */
 double fvalue;
 struct tagbintree *lchild;
 struct tagbintree *rchild;
}bintree;

char getlevel(char op);
int isop(char c);
double caltree(const bintree *node);
void distree(const bintree *node);
void destorytree(bintree **node);
void appendnode(bintree **node, char op, double value);
bintree *createtree(const char *szexpress);

int main(void)
{
 bintree *root;

 root = createtree("12*15");
 distree(root);
 printf("\n=%lf\n\n", caltree(root));
 destorytree(&root);

 root = createtree("-12+390.564*56*78-90/18.56*129.35+86.073+1345.302+10.9301*99.01");
 distree(root);
 printf("\n=%lf\n", caltree(root));
 destorytree(&root);

 getch();
}

void distree(const bintree *node)
{
 if (node == NULL)
  return;

 distree(node->lchild);
 distree(node->rchild);
 if (node->op != 0)
  printf("%c ", node->op);
 else
  printf("%f ", node->fvalue);
}

void destorytree(bintree **node)
{
 if (*node == NULL)
  return;

 if ((*node)->lchild != NULL)
  destorytree(&(*node)->lchild);
 if ((*node)->rchild != NULL)
  destorytree(&(*node)->rchild);

 free(*node);
 *node = NULL;
}

void appendnode(bintree **node, char op, double value)
{
 bintree *node1;
 bintree *node2;

 node1 = (bintree *)malloc(sizeof(bintree));
 node1->op = op;
 node1->level = getlevel(op);
 node1->fvalue = 0;

 node2 = (bintree *)malloc(sizeof(bintree));
 node2->op = 0;
 node2->level = getlevel(node2->op);
 node2->fvalue = value;
 node2->lchild = NULL;
 node2->rchild = NULL;

 node1->rchild = node2;
 if ((*node)->level != 0 && node1->level > (*node)->level)
  {
   bintree *childnode = *node;

   node1->lchild = (*node)->rchild;
   (*node)->rchild = node1;
  }
 else
  {
   node1->lchild = *node;
   *node = node1;
  }
}

char getlevel(char op)
{
 if (op == 0)
  return 0;

 if (op == '*' || op == '/')
  return 2;

 if (op == '+' || op == '-')
  return 1;
}

int isop(char c)
{
 if (c == '+' || c == '-' || c == '*' || c == '/')
  return 1;

 return 0;
}

double caltree(const bintree *node)
{
 if (node->op == 0)
  return node->fvalue;
 if (node->op == '*')
  return caltree(node->lchild) * caltree(node->rchild);
 if (node->op == '/')
  return caltree(node->lchild) / caltree(node->rchild);
 if (node->op == '+')
  return caltree(node->lchild) + caltree(node->rchild);
 if (node->op == '-')
  return caltree(node->lchild) - caltree(node->rchild);
}

bintree *createtree(const char *szexpress)
{
 const char *ptr = szexpress;
 char op;
 static char numstr[1024] = {"0"};
 char *ptrnum = numstr;
 bintree *root;

 if (szexpress == NULL)
  return NULL;

 root = (bintree *)malloc(sizeof(bintree));
 if (*ptr == '+' || *ptr == '-')
  {
   root->op = 0;
   root->level = getlevel(root->op);
   root->fvalue = 0;
   root->lchild = NULL;
   root->rchild = NULL;
  }
 else
  {
   while(*ptr)
    {
     if (isop(*ptr))
      break;
     *ptrnum++ = *ptr;
     ptr++;
    }
   *ptrnum = '\0';

   root->op = 0;
   root->level = getlevel(root->op);
   root->fvalue = atof(numstr);
   root->lchild = NULL;
   root->rchild = NULL;
  }

 if (*ptr != '\0')
  {
   op = *ptr;
   ptr++;
   ptrnum = numstr;
   while(*ptr)
    {
     if (isop(*ptr))
      {
       *ptrnum = '\0';
       appendnode(&root, op, atof(numstr));
       ptrnum = numstr;
       op = *ptr;
      }
     else
      *ptrnum++ = *ptr;
     ptr++;
    }
   *ptrnum = '\0';
   appendnode(&root, op, atof(numstr));
  }

 return root;
}