二叉树

#include<stdio.h>

#include <string.h>
#include <malloc.h>
#define MAX_NUM 100

int g_buffer[MAX_NUM];
int g_bufferNum = 0;

 

typedef struct tnode{
 int d;
 struct tnode *pleft;
 struct tnode *pright;
}TNODE;

typedef struct Stack{
 TNODE data[30];
 int top;
}STACK;

TNODE *g_ptree = NULL;
STACK g_stack;

void initNode(TNODE *pNode,int d){
 if(NULL != pNode){
  pNode->d = d;
  pNode->pleft = NULL;
  pNode->pright = NULL;
 }
 return;
}
/*添加节点*/
TNODE *addTree(TNODE *ptree,int d){
 TNODE *pNewNode = NULL;

 if(ptree==NULL){
  pNewNode = (TNODE *)malloc(sizeof(TNODE));
  if(pNewNode){
   initNode(pNewNode,d);
   ptree = pNewNode;
   printf("new a new node %d\n",pNewNode->d);
  }
 }
 else{
  if(ptree->d==d){
  }
  else if(ptree->d>d){
   ptree->pleft = addTree(ptree->pleft,d);
  }
  else{
   ptree->pright = addTree(ptree->pright,d);
  }
 }
 return ptree;
}
/*成功返回0，不成功返回-1*/
TNODE * getSuccessNode(TNODE *pNode){
 TNODE *SuccessP = pNode;
 TNODE *Success = pNode;
 TNODE *Cur = pNode->pright;
 while(Cur){
  SuccessP = Success;
  Success = Cur;
  Cur = Cur->pleft;
 }
 
 if(Success != pNode->pright){
  SuccessP->pleft = Success->pright;
  Success->pright = pNode->pright;
 }
 return Success;
}
/*删除节点*/
int removeTreeNode(TNODE **pptree,int d){
 TNODE *pParent = NULL;
 TNODE *pCur = *pptree,*psuccessNode = NULL;
 bool isFind = false;
 bool isLeftChild = false;
 if(!pptree){
  return -1;
 }
 while(pCur->d != d){
  pParent = pCur;
  if(pCur->d >d){
   isLeftChild = true;
   pCur = pCur->pleft;
  }
  else{
   isLeftChild = false;
   pCur = pCur->pright;
  }
  if(!pCur){
   return -1;
  }
 }
 /*已经找到了*/
 
 if(!pCur->pleft && !pCur->pright){
  /*(1)节点没有子节点*/
  if(pCur == *pptree){
   *pptree = NULL;
  }
  else{
   if(isLeftChild){
    pParent->pleft = NULL;
   }
   else{
    pParent->pright = NULL;
   }
  }
  
 }
 else if(!pCur->pright){
  /*(2.1)只有左节点*/
  if(pCur == *pptree){
   *pptree = pCur->pleft;
  }
  else{
   if(isLeftChild){
    pParent->pleft = pCur->pleft;
   }
   else{
    pParent->pright = pCur->pleft;
   }
  }
 }
 else if(!pCur->pleft){
  /*(2.1)只有右节点节点*/
  if(pCur == *pptree){
   *pptree = pCur->pright;
  }
  if(isLeftChild){
    pParent->pleft = pCur->pright;
  }
  else{
   pParent->pright = pCur->pright;
  }
 }
 else{
  psuccessNode = getSuccessNode(pCur);
  if(pCur == *pptree){
   *pptree = psuccessNode;
  }
  if(isLeftChild){
    pParent->pleft = psuccessNode;
  }
  else{
   pParent->pright = psuccessNode;
  }
  psuccessNode->pleft = pCur->pleft;
 }
 printf("remove %d \n",pCur->d);
 free(pCur);
 return 0;
}
void printNode(TNODE *ptree){
 printf("ptree =    ");
 if(ptree){
  printf("%d\n",ptree->d);
  if(ptree->pleft){
   printNode(ptree->pleft);
  }
  if (ptree->pright){
   printNode(ptree->pright);
  }
 }
 return;
}
int findMin(TNODE *ptree){
 if(!ptree){
  return -1;
 }
 if(ptree->pleft){
  return findMin(ptree->pleft);
 }
 else{
  return ptree->d;
 }
}
int findMax(TNODE *ptree){
 if(!ptree){
  return -1;
 }
 if(ptree->pright){
  return findMax(ptree->pright);
 }
 else{
  return ptree->d;
 }
}

void initStack(){
 g_stack.top = 0;
}
/*非递归实现二叉树的前序遍历，要求时间复杂度和空间复杂度都是O(n)*/
void pre(TNODE *pNode){
 
}

main(){
 int i = 5;
 addTree(g_ptree,6);
 addTree(g_ptree,4);
 addTree(g_ptree,3);
 addTree(g_ptree,5);
 addTree(g_ptree,7);
 addTree(g_ptree,8);

 printNode(g_ptree);
 //printf("findMin  %d\n",findMin(g_ptree));
 //printf("findMax  %d\n",findMax(g_ptree));
 //removeTreeNode(&g_ptree,0);
 //printNode(g_ptree);
}