C 언어 데이터 구조 이 진 트 리 의 앞 순서, 뒤 순서, 비 재 귀적 으로 이 루어 진 중간 순서.

/ / 이 진 트 리 의 앞 순서, 뒤 순서, 비 재 귀적 인 중간 순서

/*
       
      
        
                  
*/
#include
#include
#define MAXSIZE 1024
#define MAXNODE  100
static int id=0;
typedef struct elementtype//       
{
    char name[MAXSIZE];
    int id;
}ElementType;
typedef struct treenode//        
{
    ElementType data;
    struct treenode*left;//   
    struct treenode*right;//   
}TreeNode;
typedef struct binarytree//       
{
    TreeNode *root;
     int length;//  
     int depth;//  
     int diameter;//             
}BinaryTree;
void init_binarytree(BinaryTree*tree);//       
int  creat_binarytree(TreeNode*root);//      
void test_binarytree();//    
void preordertrevers(TreeNode*node);//    
//void inordertravers(TreeNode*node);//    
void postordertravers(TreeNode*node);//    
void inordertravers(TreeNode*tp);//    （     ）
int main()
{
    test_binarytree();
    return 0;
}
void init_binarytree(BinaryTree*tree)//       
{
    if(tree==NULL)
        return ;
    else
    {
        tree->depth=0;
        tree->diameter=0;
        tree->length=0;
        tree->root=NULL;
    }

}
int  creat_binarytree(TreeNode*root)//      
{
    if(root==NULL)
        return ;
     char inputname[MAXSIZE];
      //printf("     :
");
       gets(inputname);
       if(strcmp(inputname,"\0")==0)
       {//             \0       
    
           return 0;

       }
       strcpy(root->data.name,inputname);
         root->data.id=++id;
         //           
         root->left=(TreeNode*)malloc(sizeof(TreeNode));
         root->right=(TreeNode*)malloc(sizeof(TreeNode));
         printf("     :
");
          if( creat_binarytree(root->left)==0)
          {
              //    
              free(root->left);
              root->left=NULL;

          }
          printf("     :
");
          if(creat_binarytree(root->right)==0)
          {
              //    
              free(root->right);
              root->right=NULL;
              }
            return 1;

}
void test_binarytree()//    
{
    BinaryTree tree;//       

       init_binarytree(&tree);
       tree.root=(TreeNode*)malloc(sizeof(TreeNode));
         printf("        :
");
       creat_binarytree(tree.root);
         // free(tree.root);
       printf("        :
");
       preordertrevers(tree.root);
       printf("
");
       printf("        ;
");
       inordertravers(tree.root);
        printf("
");
       printf("        ;
");
                postordertravers(tree.root);
}
void preordertrevers(TreeNode*node)//    
{
    if(node!=NULL)
    {
        printf("[%d,%s]-",node->data.id,node->data.name);
        preordertrevers(node->left);
        preordertrevers(node->right);
    }
}
// *    ->     *     .   
/*void inordertravers(TreeNode*node)//       
{
    if(node)
    {    // -> ->        
        inordertravers(node->left);
        printf("[%d,%s]-",node->data.id,node->data.name);
        inordertravers(node->right);
    }
}*/
void postordertravers(TreeNode*node)//    
{     //      -> -> 
    if(node)
    {
         postordertravers(node->left);
         postordertravers(node->right);
        printf("[%d,%s]-",node->data.id,node->data.name);
    }
}
void inordertravers(TreeNode*tp)//    
{
 //              
 //           
//                                      
   TreeNode*s[MAXNODE];//            
   TreeNode*p;
      p=tp;//        
    int top=-1;

     if(p==NULL)
     {
        
        return ;
     }
    do
     {
         while(p!=NULL)
         {
             if(top+1>=MAXNODE)//            
             {
                 printf("   :
");
                 return ;

             }
             s[++top]=p;
             p=p->left;

            }
            if(top==-1)//         
                return;
                else{
                    p=s[top--];//      
                    printf("[%d,%s]-",p->data.id,p->data.name);//    
                     p=p->right;
                }

     }while(p!=NULL||top!=-1);

}