二叉查找树

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

#define MaxSize 1000

typedef int ElementType;

struct BinarySearchTreeNode
{
    ElementType Element;
    struct BinarySearchTreeNode *Left;
    struct BinarySearchTreeNode *Right;
};

struct BinarySearchTreeNode *BinarySearchTreeInit()
{
    struct BinarySearchTreeNode *TreeRoot = NULL;
    
    return TreeRoot;
}

int BinarySearchTreeDestroy(struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot != NULL)
    {
        BinarySearchTreeDestroy(TreeRoot -> Left);
        BinarySearchTreeDestroy(TreeRoot -> Right);
        free(TreeRoot);
    }
    return 0;
}

struct BinarySearchTreeNode *BinarySearchTreeNodeFind(ElementType ToBeFind,struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }
    
    if(ToBeFind < TreeRoot -> Element)
    {
        return BinarySearchTreeNodeFind(ToBeFind,TreeRoot->Left);
    }
    else if(ToBeFind > TreeRoot -> Element)
    {
        return BinarySearchTreeNodeFind(ToBeFind,TreeRoot->Right);
    }
    else
    {
        return TreeRoot;
    }
}

struct BinarySearchTreeNode *BinarySearchTreeNodeFindMin(struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }
    else if(TreeRoot->Left==NULL)
    {
        return TreeRoot;
    }
    else
    {
        return BinarySearchTreeNodeFindMin(TreeRoot->Left);
    }
}

struct BinarySearchTreeNode *BinarySearchTreeNodeFindMax(struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }
    else if(TreeRoot->Right==NULL)
    {
        return TreeRoot;
    }
    else
    {
        return BinarySearchTreeNodeFindMax(TreeRoot->Right);
    }
}

//be careful of return NULL 
struct BinarySearchTreeNode *BinarySearchTreeNodeInsert(ElementType ToBeInsert,struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        TreeRoot = malloc(sizeof(struct BinarySearchTreeNode));
        TreeRoot -> Element = ToBeInsert;
        TreeRoot -> Left = TreeRoot -> Right = NULL;
    }
    else if(ToBeInsert < TreeRoot->Element)
    {
        TreeRoot -> Left = BinarySearchTreeNodeInsert(ToBeInsert,TreeRoot->Left);
    }
    else if(ToBeInsert > TreeRoot->Element)
    {
        TreeRoot -> Right = BinarySearchTreeNodeInsert(ToBeInsert,TreeRoot->Right);
    }
    return TreeRoot;
}

//if doesn't find,return NULL
struct BinarySearchTreeNode *BinarySearchTreeNodeDelete(ElementType ToBeDelete,struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot == NULL)
        return NULL;
    
    struct BinarySearchTreeNode *TmpCell;
    
    if(ToBeDelete < TreeRoot -> Element)
    {
        TreeRoot -> Left = BinarySearchTreeNodeDelete(ToBeDelete,TreeRoot->Left);
    }
    else if(ToBeDelete > TreeRoot -> Element)
    {
        TreeRoot -> Right = BinarySearchTreeNodeDelete(ToBeDelete,TreeRoot->Right);
    }
    else //if(ToBeDelete == TreeRoot -> Element)
    {
        if(TreeRoot->Left && TreeRoot->Right)
        {
            TmpCell = BinarySearchTreeNodeFindMin(TreeRoot -> Right);
            TreeRoot -> Element = TmpCell -> Element;
            TreeRoot -> Right = BinarySearchTreeNodeDelete(TreeRoot->Element,TreeRoot->Right);
        }
        else
        {
            TmpCell = TreeRoot;
            if(TreeRoot->Left==NULL)
            {
                TreeRoot = TreeRoot -> Right;
            }
            else if(TreeRoot->Right==NULL)
            {
                TreeRoot = TreeRoot -> Left;
            }
            free(TmpCell);
        }
    }
    return TreeRoot;
}


int main()
{
    struct BinarySearchTreeNode *TreeRoot = BinarySearchTreeInit();
    TreeRoot = BinarySearchTreeNodeInsert(1,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(2,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(39,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(-1,TreeRoot);
//    TreeRoot = BinarySearchTreeNodeDelete(2,TreeRoot);
//    TreeRoot = BinarySearchTreeNodeDelete(1,TreeRoot);
//    TreeRoot = BinarySearchTreeNodeDelete(39,TreeRoot);
//    FindNode = BinarySearchTreeNodeFind(2,TreeRoot);
//    FindNode = BinarySearchTreeNodeFindMin(TreeRoot);
//    FindNode = BinarySearchTreeNodeFindMax(TreeRoot);
//  BinarySearchTreeDestroy(TreeRoot);
//    printf("%d
",TreeNodeRoot->Element);
    return 0;
}