C语言之二叉树

规定：根节点的值大于左节点但小于右节点的值，所以二叉树的值插入是唯一的，最后形成的树只跟根节点有关

定义节点：

struct tree_node {
      TypeElem  elem;

struct tree_node *fa;
      struct tree_node *left;
      struct tree_node *right;
};

 #include <stdio.h>
 #include <stdlib.h>

 typedef int TypeElem;

 struct tree_node {
     TypeElem  elem;
     struct tree_node *fa;
     struct tree_node *left;
     struct tree_node *right;
 };

 struct tree_node *root_ptr;    //指向根节点的指针

 #define IS_ROOT_NODE(ptree_fa, ptree, x)  do{ if(ptree_fa) {   \
                                                     if (ptree == ptree_fa->left)   \
                                                          ptree_fa->left = x;    \
                                                     else if (ptree == ptree_fa->right)   \
                                                          ptree_fa->right = x;   \
                                           }else                                 \
                                               root_ptr = x; }while ()       //如果删除的是根节点root_ptr就变了

 /* 在父节点下插入子节点(有可能是孙子节点了) */
 struct tree_node *Insert(TypeElem  elem, struct tree_node *T_fa, struct tree_node *T)
 {
     if (T == NULL) {
         T = (struct tree_node *)malloc(sizeof(struct tree_node));
         if (!T) {
             printf("malloc error\n");
             return NULL;
         }
         T->fa = T_fa;
         T->elem = elem;
         T->left = T->right = NULL;
     }
     else if (elem < T->elem)
         T->left = Insert(elem, T, T->left);
     else if (elem > T->elem)
         T->right = Insert(elem, T, T->right);

     return T;
 }

 struct tree_node *find_val(struct tree_node *rootp, TypeElem  elem)
 {
     if (!rootp) {
         printf("don't find\n");
         return NULL;
     }
     //遍历：前序、中序、后序
     if (rootp->elem == elem)
         return rootp;
     else if (rootp->elem > elem) {
         return find_val(rootp->left, elem);   //递归
     }
     else if (rootp->elem < elem) {
         return find_val(rootp->right, elem);  //递归
     }
     return NULL;
 }

 struct tree_node *find_min_val(struct tree_node *rootp)
 {
     while (rootp->left) {
         rootp = rootp->left;
     }
     return rootp;
 }

 struct tree_node *find_max_val(struct tree_node *rootp)
 {
     while (rootp->right) {
         rootp = rootp->right;
     }
     return rootp;
 }

 int delete_tree(TypeElem  elem, int isfree)
 {
     struct tree_node *ptree = find_val(root_ptr, elem);
     struct tree_node *ptree_fa = ptree->fa;
     struct tree_node *min_tree;

     if (!ptree)
         return -;
     if (!(ptree->left) && !(ptree->right)) {
          IS_ROOT_NODE(ptree_fa, ptree, NULL);
     }
     else if (!(ptree->left) && ptree->right) {
          IS_ROOT_NODE(ptree_fa, ptree, ptree->right);
          ptree->right->fa = ptree_fa;
     }
     else if (ptree->left && !(ptree->right)) {
         IS_ROOT_NODE(ptree_fa, ptree, ptree->left);
         ptree->left->fa = ptree_fa;
     }
     else if (ptree->left && ptree->right) {
         min_tree = find_min_val(ptree->right);
         delete_tree(min_tree->elem, );   //递归
         IS_ROOT_NODE(ptree_fa, ptree, min_tree);
         min_tree->left = ptree->left;
         min_tree->right = ptree->right;
         min_tree->fa = ptree->fa;
     }
     if (isfree)
         free(ptree);
     return ;
 }

 int main()
 {
     int i;
     root_ptr = Insert(, NULL, root_ptr);    //得到指向根节点的指针 
     TypeElem a[] = { ,,,,,,,, };  //依次插入9个节点
     for (i = ; i < ; i++)
         Insert(a[i], root_ptr->fa, root_ptr);
     if (!delete_tree(, ))
         printf("delete_tree ok\n");
     if (root_ptr) {
         if (find_val(root_ptr, ))
             printf("find node\n");
     }
    
     return ;
 }

 

形成的树结构：

如果删除根节点6，依然能找到节点9