二叉排序树

#include <iostream>
#include <new>
using namespace std;
#define  __WINDOWS__
//struct BinaryTreeData
//{
//    int d;
//};
typedef int  BinaryTreeData ;
typedef int  BinaryNum;
BinaryTreeData   g_fileData[1024];
int  g_fileSize=0;
struct  BinarySortTree
{
    BinaryTreeData data;
    BinaryNum        num;
    BinarySortTree *left;
    BinarySortTree *right;
};


BinarySortTree *create()
{
    BinarySortTree * tempTree = new(nothrow) BinarySortTree;
    tempTree->left = nullptr;
    tempTree->right = nullptr;
    tempTree->num = 0;
    if (tempTree)
    {
        return tempTree;
    }
    printf("分配内存失败\n");
    return nullptr;
}

bool insert(BinarySortTree * *tree,BinaryTreeData tData)
{
    if (!(*tree))
    {
        *tree = create();
        (*tree)->data = tData;
        (*tree)->num = 1;
    }
    BinarySortTree * tempTree = *tree;
    while (tempTree)
    {
        if (tData == tempTree->data)
        {
            tempTree->num++;
            break;
        }
        if (tData >tempTree->data)
        {
            if (!tempTree->right)
            {
                tempTree->right = create();
                tempTree->right->data = tData;
                tempTree->right->num = 1;
                break;
            }
            tempTree = tempTree->right;
            
        }else
        {
            if (!tempTree->left)
            {
                tempTree->left = create();
                tempTree->left->data = tData;
                tempTree->left->num = 1;
                break;
            }
            tempTree = tempTree->left;
        }
        
    }
    return true;
}

bool del(BinarySortTree * *tree ,BinaryTreeData tData)
{

    BinarySortTree * m_head = *tree;
    BinarySortTree * m_parent=   nullptr;
    BinarySortTree * delnode =   nullptr;

    while (m_head)
    {
        if (m_head->data == tData)
        {
            break;
        }
        if (tData  < m_head->data)
        {
            m_parent = m_head;
            m_head = m_head->left;
        }else
        {
            m_parent = m_head;
            m_head = m_head->right;
        }
    }
    //没有找到
    if (!m_head)
    {
        return false;
    }
    //删除根结点
    if (!m_parent)
    {
        if (!m_head->left && !m_head->right)
        {
            *tree = nullptr;
        }else if (m_head->left && !m_head->right)
        {
            *tree = m_head->left;
        }else if (!m_head->left && m_head->right)
        {
            *tree = m_head->right;
        }else
        {
            //前驱
            BinarySortTree * precursor = nullptr;
            BinarySortTree * precursorParent = nullptr;
            precursor = m_head->left;
            while (precursor->right)
            {
                precursorParent = precursor;
                precursor = precursor->right;
            }
            //刚好为左结点
            if (!precursorParent)
            {
                *tree = precursor;
                precursor->right = m_head->right;
            }else
            {
                *tree = precursor;
                precursorParent->right = precursor->left;
                precursor->left = m_head->left;
                precursor->right = m_head->right;
            }
        }
        delete m_head;
        m_head = nullptr;
        return true;
    }
    //叶子结点
    if (!m_head->left && !m_head->right)
    {
        if (m_parent->left == m_head)
        {
            m_parent->left = nullptr;
            delete m_head;
            m_head = nullptr;
        }else if (m_parent->right == m_head)
        {
            m_parent->right = nullptr;
            delete m_head;
            m_head = nullptr;
        }
    }else
    {
        //只有左子树
        if (m_head->left &&  !m_head->right)
        {
            if (m_parent->left == m_head)
            {
                m_parent->left = m_head->left;
                delete m_head;
                m_head = nullptr;
            }else if (m_parent->right == m_head)
            {
                m_parent->right = m_head->left;
                delete m_head;
                m_head = nullptr;
            }
        }else
        //只有右子树
        if (m_head->right && !m_head->left)
        {
            if (m_parent->left == m_head)
            {
                m_parent->left = m_head->right;
                delete m_head;
                m_head = nullptr;
            }else if (m_parent->right == m_head)
            {
                m_parent->right = m_head->right;
                delete m_head;
                m_head = nullptr;
            }
        }else
        //既有左子树又有右子树
        if (m_head->right && m_head->left)
        {
            //前驱
            BinarySortTree * precursor = nullptr;
            BinarySortTree * precursorParent = nullptr;
            precursor = m_head->left;
            while (precursor->right)
            {
                precursorParent = precursor;
                precursor = precursor->right;
            }
            //左结点刚好为删除结点前驱
            if (!precursorParent)
            {
                if (m_parent->left == m_head)
                {
                    m_parent->left = precursor;
                
                    precursor->right = m_head->right;
                    delete m_head;
                    m_head = nullptr;
                }else if (m_parent->right == m_head )
                {
                    m_parent->right = precursor;
                    precursor->right = m_head->right;
                    delete m_head;
                    m_head = nullptr;
                }
            }else
            {
                if (m_parent->left == m_head)
                {
                    m_parent->left = precursor;
                    precursorParent->right = precursor->left;
                    precursor->left = m_head->left;
                    precursor->right = m_head->right;
                    delete m_head;
                    m_head = nullptr;
                }else if (m_parent->right == m_head )
                {
                    m_parent->right = precursor;

                    precursorParent->right = precursor->left;
                    precursor->left = m_head->left;
                    precursor->right = m_head->right;
                    delete m_head;
                    m_head = nullptr;
                }
            }
        }
    }
    return true;
}

void print(BinarySortTree * tree)
{
    if (tree)
    {
        print(tree->left);
        printf("%d ",tree->data);
        print(tree->right);
    }
}

//整数
int s2num(const char * data)
{
    int num=0;
    while (*data!='\0')
    {
        num = num * 10 + (*data ^ '0');
        data++;
    }
    return num;
}

//从in.txt文件中读取数据
bool readData(BinaryTreeData *data)
{
    FILE * file = fopen("in.txt","rb");
    fseek(file,0L,SEEK_END);
    int size = ftell(file);
    fseek(file,0L,SEEK_SET);
    if (size < 0 )
    {
        fclose(file);
        return false;
    }
    char buf[1024];
    memset(buf,0,sizeof(buf));
    fread(buf,size,1,file);
    fclose(file);

#ifdef __WINDOWS__
    const char * split=" \r\n";
#else
    const char * split=" \n";
#endif
    g_fileSize = 0;
    char *temp = NULL;
    char * str = strtok_s(buf,split,&temp);
    while (str)
    {
        g_fileData[g_fileSize++] = s2num(str) ;
        str = strtok_s(NULL,split,&temp);
    }
    return true;
}

int main()
{
    memset(g_fileData,0,sizeof(g_fileData));
    readData(g_fileData);
    BinarySortTree * m_tree = nullptr;
    for (int i=0;i<g_fileSize;i++)
    {
        insert(&m_tree,g_fileData[i]);
    }
    print(m_tree);
    printf("\n");
    del(&m_tree,12);
    print(m_tree);
    printf("\n");
    return 0;
}