Бинарное дерево

-
                          +                   -
                 *            5         sin       5
             1      2               (1)

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

int sintaks(char *str)
{
   int i=0, sk=0;
   while(str!='\0')
   {
      if(str=='(')
     sk++;
      if(str==')')
     sk--;
      if(sk<0)
     return 1;
      i++;
   }
   if(sk==0)
      return 0;
   else
      return 1;
}

int proverka(char *str, int sk)
{
   if((*str==')')&&(sk==0))
      return 1;
   return 0;
}

int letter(char *str)
{
   char *item="CcEeGgIiLlNnOoPpSsTtXx";
   int i=0;
   while(item!='\0')
   {
      if(*str==item)
      return 1;
      i++;
   }
   return 0;
}

struct treeNode
{
   struct treeNode *left;
   //char *data;
   char data[100];
   struct treeNode *right;
};

typedef struct treeNode TREENODE;
typedef TREENODE *TREENODEPTR;

void inOrder(TREENODEPTR tree)
{
   if(tree!=NULL)
   {
      inOrder(tree->left);
      printf("%s",tree->data);
      inOrder(tree->right);
   }
}

void write(TREENODEPTR *treePtr, char *str)
{
   int k,i=0;
   if((str[0])!='\0')
   {
      if(*treePtr==NULL)
      {
     *treePtr=(treeNode *)malloc(sizeof(TREENODE));
     if(*treePtr!=NULL)
     {
        k=0;
        while(str!='\0')
        {
           (*treePtr)->data[k]=str;
           k++; i++;
        }
        (*treePtr)->data[k]='\0';
        (*treePtr)->left=NULL;
        (*treePtr)->right=NULL;
     }
     else
        printf("%c not inserted. No memory avaliable.\n", str);
      }
      else
      {
     write(&((*treePtr)->left),str);
      }
   }
}


void insertNode(TREENODEPTR *treePtr, char *str)
{
   //char *strmas, *smas, *masL, *masR;
   char strmas[100], smas[100], masL[100], masR[100], fmas[100];
   int flag=0, itemflag=0, k=0, sk=0, l=0, r=0, f=0;
   int i=0;

   if(str[0]=='(')
   {
      i++;
      sk=0; flag=0;
      while(proverka(&str,sk)!=1)
      {
     if((flag==0)&&(sk==0)&&(letter(&str[1])==1))
     {
        k=0; flag=1; itemflag=1;
        while(str!='(')
        {
           strmas[k]=str;
           i++; k++;
        }
        strmas[k]='\0';
        // write in the root of the tree
        if(*treePtr==NULL)
        {
           *treePtr=(treeNode *)malloc(sizeof(TREENODE));
           if(*treePtr!=NULL)
           {
          k=0;
          while(strmas[k]!='\0')
          {
             (*treePtr)->data[k]=strmas[k];
             k++;
          }
          (*treePtr)->data[k]='\0';
          (*treePtr)->left=NULL;
          (*treePtr)->right=NULL;
           }
           else
          printf("%s not inserted. No memory avaliable.\n", strmas);
        }
        else
        {
           insertNode(&((*treePtr)->left),strmas);
        }
        ///////////////////////////////////////////
        while(proverka(&str,sk)!=1)
        {
           fmas[f]=str;
           if(proverka(&str[i+1],0)==1)
           {
          fmas[f+1]=')';
          fmas[f+2]='\0';
           }
           i++; f++;
        }
        write(&(*treePtr)->left,fmas);
        break;//continue;
        ///////////////////////////////////////////
     }

     if(((str=='+')||(str=='-')||(str=='*')||(str=='/'))&&(flag==0)&&(sk==0))
     {
        flag=1;
        smas[0]=str;
        smas[1]='\0';
        // write in the root of the tree
        if(*treePtr==NULL)
        {
           *treePtr=(treeNode *)malloc(sizeof(TREENODE));
           if(*treePtr!=NULL)
           {
          (*treePtr)->data[0]=smas[0];
          (*treePtr)->data[1]='\0';
          (*treePtr)->left=NULL;
          (*treePtr)->right=NULL;
           }
           else
          printf("%s not inserted. No memory avaliable.\n", smas);
        }
        else
        {
           insertNode(&((*treePtr)->left),smas);
        }
        i++;
     }

     if(flag==0)
     {
        if(str=='(')
           sk++;
        if(str==')')
           sk--;
        masL[l]=str;
        l++;
     }

     if(flag!=0)
     {
        if(str=='(')
           sk++;
        if(str==')')
           sk--;
        masR[r]=str;
        r++;
        if(proverka(&str[i+1],0)==1)
        {
           masL[l]='\0';
           masR[r]='\0';
        }
     }

     i++;
      }

      // rekursia

      if((flag==1)&&(itemflag==0))
      {
     insertNode(&((*treePtr)->left),masL);
     insertNode(&((*treePtr)->right),masR);
      }

   }
   else
   {
      if((str[0])!='\0')
      {
     if(*treePtr==NULL)
     {
        *treePtr=(treeNode *)malloc(sizeof(TREENODE));
        if(*treePtr!=NULL)
        {
           k=0;
           while(str!='\0')
           {
          (*treePtr)->data[k]=str;
          k++; i++;
           }
           (*treePtr)->data[k]='\0';
           (*treePtr)->left=NULL;
           (*treePtr)->right=NULL;
        }
        else
           printf("%c not inserted. No memory avaliable.\n", str);
     }
     else
     {
        insertNode(&((*treePtr)->left),str);
     }
      }
   }
}




void main(void)
{
   clrscr();
   FILE *f=fopen("c:\\1.txt","r");
   char item, *str;
   int i=0;
   while(!feof(f))
   {
      item=getc(f);
      if(item!='\0')
      {
     if(i>1)
        str[i-2]=item;
      i++;
      }
   }
   fclose(f);
   i-=3;
   str='\0';
   printf("%s\n", str);
   //////////////////////////////////////////////////////////////

   int k=sintaks(str);
   if(k==0)
   {
      TREENODEPTR rootPtr=NULL;
      insertNode(&rootPtr,str);
      printf("\n");
      inOrder(rootPtr);
   }
      else
     printf("error!");

    getch();
}