二叉树计算中缀表达式（二）

         二叉树计算中缀表达式，支持指数运算符“^”，暂时不支持括号，直接以字符串形式输入。

#include <stdio.h>
#include <conio.h>
#include <math.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);

 printf("\n1+2*3*2^0.5*3^0.3-6\n");
 root = createtree("1+2*3*2^0.5*3^0.3-6");
 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 *rp = *node;

   while(rp->rchild->level != 0 && node1->level > rp->rchild->level)
    {
     rp = rp->rchild;
    }
   node1->lchild = rp->rchild;
   rp->rchild = node1;
  }
 else
  {
   node1->lchild = *node;
   *node = node1;
  }
}

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

 if (op == '^')
  return 3;

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

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

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

 return 0;
}

double caltree(const bintree *node)
{
 if (node->op == 0)
  return node->fvalue;
 if (node->op == '^')
  return pow(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);
 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;
}