以另外一种方式写二叉树,感受很深啊!

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
typedef struct Node{
 
  int num;
  struct Node* left;
  struct Node* right;
}NODE,*PNODE;
class CTree
{
  public:
    CTree(){ init();}
    ~CTree(){ deInit(pRoot);}
    PNODE searchFromTree(int num)
    {

      return searchFromTree(pRoot,num);
    }
    int insertToTree(int num)
    {
       
       PNODE pNode = getNode();
       if(!pNode) return 0;
       pNode->num = num;
       if(!pRoot)
       {
         pRoot = pNode;
         return 1;
       }
       PNODE pTmp = searchFromTree(num);

       if(!pRoot)
       {
         pRoot = pNode;
         return 1;
       }
       if(num > pTmp->num)
       {
       
         pTmp->right = pNode;
       }
       else
       {
        
         pTmp->left = pNode;
       }
       return 1;
    }
    void midSearchDeal(void (*pFunc)(int))
    {
      if(!pRoot)
       return;
      midSearchDeal(pRoot,pFunc);
    }
    void prevSearchDeal(void (*pFunc)(int))
    {
      if(!pRoot)
        return;
      prevSearchDeal(pRoot,pFunc);
    }
    void tailSearchDeal(void (*pFunc)(int))
    {
      if(!pRoot) return;
      tailSearchDeal(pRoot,pFunc);
    }
    void removeFromTree(int num)
    {
       PNODE pTmp = NULL;
       PNODE pPar = NULL;
       int position = 0;
       PNODE pNode = matchFromTree(pRoot,&pPar,num,&position);
       
       if(!pNode) return;
       if(pNode->left && pNode->right)
       {
         if(position == 1)
             pPar->right = pNode->left;
         else
             pPar->left = pNode->left;
         pTmp = pNode->left;
         while(pTmp->right)
         {
           pTmp = pTmp->right;
         }
         pTmp->right = pNode->right;
         
       }
       else if(pNode->left && pNode->right==NULL)
       {
           pTmp = pNode;      
          if(position == 1)
             pPar->right = pNode->left;
          else
             pPar->left = pNode->left;
       }
       else if(pNode->left == NULL && pNode->right)
       {
          pTmp = pNode;
          
          if(position == 1)
             pPar->right = pNode->right;
          else
             pPar->left = pNode->right;
          
       }
       free(pNode);
    }
  private:
    PNODE matchFromTree(PNODE pNode,PNODE* pParNode,int num,int *p)
    {
      
         if(pNode->num==num||pNode==NULL)
            return pNode;
         else if(num > pNode->num)
         {
                   *pParNode = pNode;
                   *p = 1;
            return matchFromTree(pNode->right,pParNode,num,p);
         }
         else
         {
                   *pParNode = pNode;
                   *p = -1;
            return matchFromTree(pNode->left,pParNode,num,p);
         }
    }
    PNODE pRoot;
    void tailSearchDeal(PNODE pNode,void (*pFunc)(int))
    {
      if(!pNode) return;
      tailSearchDeal(pNode->left,pFunc);
      tailSearchDeal(pNode->right,pFunc);
      pFunc(pNode->num);
    }
    void prevSearchDeal(PNODE pNode,void (*pFunc)(int))
    {
      if(!pNode) return;
      pFunc(pNode->num);
      prevSearchDeal(pNode->left,pFunc);
      prevSearchDeal(pNode->right,pFunc);
    }
    void midSearchDeal(PNODE pNode,void (*pFunc)(int))
    {
        if(!pNode)
          return;
        midSearchDeal(pNode->left,pFunc);
        pFunc(pNode->num);
        midSearchDeal(pNode->right,pFunc);
    }
    void init()
    {
      pRoot = NULL;
    }
    PNODE searchFromTree(PNODE pNode,int num)
    {
    
      if(pNode->num == num)
       return pNode;
      else if(num > pNode->num)
      {
        if(pNode->right == NULL) return pNode;
        return searchFromTree(pNode->right,num);
      }
      else
      {
        if(pNode->left == NULL) return pNode;
        return searchFromTree(pNode->left,num);
      }
      
    }
    void deInit(PNODE pNode)
    {
      if(pNode == NULL)
       return;
      
      deInit(pNode->left);
      deInit(pNode->right);
      free(pNode);
      pNode = NULL;
    }
    PNODE getNode()
    {
      PNODE pNode = (PNODE)malloc(sizeof(NODE));
      if(!pNode)
      {
       printf("内存分配失败") ;
       return NULL;
      }
      memset(pNode,0,sizeof(NODE));
      return pNode;
    }
};
void print(int num)
{
  printf("%d\n",num);
}
int main(int argc,char* argv[])
{
   CTree tree;
   int ret = tree.insertToTree(5);

   ret = tree.insertToTree(7);

   ret = tree.insertToTree(6);

   ret = tree.insertToTree(10);
    
   ret = tree.insertToTree(1);

   tree.prevSearchDeal(print);
   tree.removeFromTree(7);
   tree.prevSearchDeal(print);
   return 0;
}