二叉查找树的结点插入，查找，删除，计算二叉树的高度

/***二叉查找树的结点插入，查找，删除，计算树的高度*****/

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

    typedef int type_t;//可扩展属性

    typedef struct node
    {
        type_t data;
        struct node *left;
        struct node *right;
    }Node;
    /***************创建树******************/
    Node *tree_create(type_t data)
    {
        Node *ptree = malloc(sizeof(Node));
        ptree->data = data;
        ptree->left = NULL;
        ptree->right = NULL;

        return ptree;
    }
    /****************非递归法插入结点*****************/
    void node_insert(Node **ptree,Node *pnode)
    {
        if(!*ptree)
            *ptree = pnode;
        else
        {
            Node *p = *ptree;
            Node *parent = NULL;

            while(NULL != p)
            {
                parent = p;
                if(pnode->data < p->data)
                {
                    p = p->left;
                }

                else
                {
                    p = p->right;
                }
            }
            if(pnode->data < parent->data)
            {
                parent->left = pnode;
            }
            else
            {
                parent->right = pnode;
            }
        }

    }
    /****************递归插入结点*****************/
    void node_insert_by_recursion(Node **ptree,Node *pnode)
    {
        if(!*ptree)
            *ptree = pnode;
        else
        {
            if(pnode->data < (*ptree)->data)
            {
                node_insert_by_recursion(&((*ptree)>left),pnode);   
            }
            else
            {
                node_insert_by_recursion(&((*ptree)->right),pnode);
            }
        }
    }
    /****************前序遍历*****************/
    int tree_pre_order(Node *tree)
    {
        if(NULL == tree)
            return;
        else
        {
            printf("%d ",tree->data);
            tree_in_order(tree->left);
            tree_in_order(tree->right);
        }
    }
    /****************中序遍历*****************/
    int tree_in_order(Node *tree)
    {
        if(NULL == tree)
            return;
        else
        {
            tree_in_order(tree->left);
            printf("%d ",tree->data);
            tree_in_order(tree->right);
        }
    }
    /****************后序遍历*****************/
    int tree_post_order(Node *tree)
    {
        if(NULL == tree)
            return;
        else
        {
            tree_in_order(tree->left);
            tree_in_order(tree->right);
            printf("%d ",tree->data);
        }
    }
    /****************查找结点*****************/
    Node *search_node(Node *tree,int data)
    {
        if (!tree)
            return NULL;
        else
        {
            if (tree->data == data)
            {
                return tree;
            }
            else if(tree->data < data)
                return search_node(tree->right,data);
            else
                return search_node(tree->left,data);
        }
    }
    /************计算树的高度***************/
    int tree_height(Node *tree)
    {
        if(!tree)
            return;
        else
        {
            int lh = tree_height(tree->left);
            int rh = tree_height(tree->right);
            if(lh < rh)
                return rh + 1;
            else
                return lh + 1;
        }
    }

    /*删除结点*/
    void node_delete(Node **ptree, int data)
    {
        Node *pFind = *ptree;
        Node *pParent = NULL;
        Node *pDelete = NULL;
        /*查找要删除的结点及其父结点*/
        while(pFind != NULL)
        {
            if(pFind->data == data)
                break;
            else if(data < pFind->data)
            {
                pParent = pFind;
                pFind = pFind->left;
            }
            else
            {
                pParent = pFind;
                pFind = pFind->right;
            }
        }
        if(pFind == NULL)/*查找完毕，未找到要删除的数据*/
        {
            return;
        }
        else if(pFind->left == NULL) /*要删除的结点没有左子树，则直接将右子树的数据移过来*/
        {
            if(pParent == NULL) /*待删除结点是根结点*/
            {
                *ptree= pFind->right;
            }
            else
            { 
                if(pParent->left == pFind)
                {
                    pParent->left = pFind->right;
                }
                else
                {
                    pParent->right = pFind->right;
                }

            }
                free(pFind);
                return;
        }
        else if(pFind->left->right == NULL)/*待删除结点的左子树没有右结点，则删除find->left结点*/
        {
            pDelete = pFind->left;
            pFind->data = pDelete->data;
            pFind->left = pDelete->left;
            free(pDelete);
            return;
        }
        else /*待删除结点的左子树至少有一个右结点，需要查找到左子树的最右结点，将其删除*/
        {
            pParent = pFind->left;
            pDelete = pParent->right;
            while(pDelete->right != NULL)
            {
                pParent = pDelete;
                pDelete = pDelete->right;
            }
            pParent->right = pDelete->left;
            pFind->data = pDelete->data;
            free(pDelete);
            return;
        }

    }
    /****************销毁树*****************/
    void tree_destroy(Node **ptree)   //从根节点开始遍历
    {
        if (*ptree == NULL)
        {
            return ;
        }
        **重点内容**
            Node *p = *ptree;
            tree_destroy(&(p->left));//递归左子树
            tree_destroy(&(p->right));//递归右子树

            printf("\ndelete %d", p->data);
            free(p);         //释放每轮递归的根节点
            *ptree = NULL；   //避免ptree成为野指针
    }
    int main()
    {
        Node *ptree= NULL;  //根节点
        Node *pnode = NULL;  //待插入结点
        int i;
        int a[5] = {1,3,3,5,6};
        for(i = 0; i < 5; i++)
        {
            pnode = tree_create(a[i]);   //新子树生成
            node_insert(&ptree,pnode);   //非递归法
            //node_insert_by_recursion(&ptree,pnode);//递归法
        }
        printf("中序遍历\n");
        tree_in_order(ptree);

    //  printf("前序遍历\n");
    //  tree_pre_order(ptree);
    //  printf("后序遍历\n");
    //  tree_post_order(ptree);     

        printf("\n高度:");
        int height = tree_height(ptree);
        printf("%d\n", height);

        printf("查找某个数,输入：");
        scanf("%d",&i);
        pnode = search_node(ptree,i);

        if(pnode != NULL)
        {
            printf("%d\n",pnode->data);
        }
        else
        {
            printf("not found\n");
        }
        printf("删除结点\n");
        node_delete(&ptree,3);
        tree_in_order(ptree);

        tree_destroy(&ptree);
        return 0;
    }
    经检测，运行结果正确。