二叉排序树的插入、删除、查找、中序遍历代码

纯作代码记录，无详细分析

BTree.h头文件

#include <stack>
#include <iostream>

#ifndef BTREE_H_
#define BTREE_H_
//二叉树
struct BTree
{
    //成员
    char data;
    BTree* left;
    BTree* right;
    
    #pragma region 函数
    BTree();
    BTree(char data_);

    //用递归中序遍历
    virtual void midOrder(void (*visit)(BTree*));
    virtual BTree* find(char data_);


    #pragma endregion
};

//排序二叉树
typedef struct BSTree:BTree
{
    BSTree* left;
    BSTree* right;

    BSTree();
    BSTree(char data_);
    void insert(char data_);
    virtual void midOrder(void (*visit)(BTree*));
    virtual BSTree* find(char data_);
    BSTree* delRecursion(char data_);
} * BST;

void coutVisit(BTree* p);

#endif

BTree.cpp结构体实现

#include "BTree.h"

void coutVisit(BTree* p)
{
    std::cout << p->data << std::endl;
}

#pragma region BTree实现

BTree::BTree()
{
    left=nullptr;
    right=nullptr;
}//默认构造函数也要“实现”一下

BTree::BTree(char data_)
{
    data=data_;
    left=nullptr;
    right=nullptr;
}

BTree* BTree::find(char data_)
{
    return nullptr;
}

void BTree::midOrder(void (*visit)(BTree*))
{
    BTree* p=this;
    std::stack<BTree*> st;
    while(!st.empty()||p!=nullptr)
    {
        if(!p)                  //指针空，三种可能1.基本情况，p双亲左孩子是null，出栈，对应递归函数的返回   2.非基本但也是基本，这棵树找完了，还是出栈  3.右子树null啥都没有，也是出栈
        {                           
            p=st.top();
            st.pop();
            (*visit)(p);        //访问函数
            p=p->right;         //1.左边找尽了，还要看看有没有右子树
            continue;
        }
        st.push(p);
        p=p->left;
    }        
}

#pragma endregion

#pragma region BSTree实现
BSTree::BSTree()
{
    left=nullptr;
    right=nullptr;
}
BSTree::BSTree(char data_)
{
    data=data_;
    left=nullptr;
    right=nullptr;
}

void BSTree::insert(char data_)
{
    BSTree* newNode=new BSTree(data_);
    BSTree* p=this;
    BSTree* pre=nullptr;
    while(p)
    {
        if(p->data > data_)
        {
            pre=p;
            p=p->left;
        }
        else
        {
            pre=p;
            p=p->right;
        }
    }
    if(data_ > pre->data)
        pre->right=newNode;
    else if(data_< pre->data)
        pre->left=newNode;
    else
    {
        std::cout<<"insert failed\n";
        delete newNode;
    }
    
}

void BSTree::midOrder(void (*visit)(BTree*))
{
    BSTree* p=this;
    std::stack<BSTree*> st;
    while(!st.empty()||p!=nullptr)
    {
        if(!p)                  //指针空，三种可能1.基本情况，p双亲左孩子是null，出栈，对应递归函数的返回   2.非基本但也是基本，这棵树找完了，还是出栈  3.右子树null啥都没有，也是出栈
        {                           
            p=st.top();
            st.pop();
            (*visit)(p);        //访问函数
            p=p->right;         //1.左边找尽了，还要看看有没有右子树
            continue;
        }
        st.push(p);
        p=p->left;
    }        
}

BST BSTree::find(char data_)
{
    if(data_==this->data)
        return this;
    if(data_< this->data && this->left)
    {
        return this->left->find(data_);
    }
    else if(this->right)
    {
        return this->right->find(data_);
    }
    else
    {
        return nullptr;
    }
}

BSTree* BSTree::delRecursion(char data_)//返回新的根,递归,基本情况是this的data就等于data_或不相等且没有需要的子树
{
    //找结点
    if(this->data > data_ && this->left)//data_小，找左子树
    {
        this->left = this->left->delRecursion(data_);
    }
    else if(this->data < data_ && this->right)//data_大，找右子树
    {
        this->right = this->right->delRecursion(data_);
    }
    else if(this->data != data_)//没找到需要的左、右子树
    {
        std::cout<<"no such BSTNode as "<<data_<<std::endl;
    }
    else//找到了
    {
        //情况一：要删的结点有左右子树
        if(this->left && this->right)
        {
            //找左子树最右边的结点与本结点替换，然后把那个叶子删掉
            BST pre=nullptr;
            BST p=this->left;
            while(p->right)
            {
                pre=p;
                p=p->right;
            }
            //p就是要删的，用来和this替换的
            this->data=p->data;//替换
            if(pre)
                pre->right=nullptr;                
            else//说明刚好左孩子是叶子
                this->left=nullptr;
            delete p;
            p=nullptr;
        }
        //情况二：要删的结点最多有一个子树
        else
        {
            //本结点删了，返回孩子给父亲就好了
            BST onlyChild=nullptr;
            if(this->left)
            {
                onlyChild=this->left;
            }
            else
            {
                onlyChild=this->right;
            }
            delete this;
            return onlyChild;
        }
    }
    return this;
}

#pragma endregion

main.cpp测试

#include "BTree.h"

void testMidOrder()
{
    BTree* root=new BTree('A');
    BTree* b=new BTree('B');
    BTree* c=new BTree('C');
    BTree* d=new BTree('D');
    BTree* e=new BTree('E');
    BTree* f=new BTree('F');
    BTree* g=new BTree('G');

    root->left=b;
    root->right=g;
    b->left=c;
    b->right=d;
    d->left=e;
    e->right=f;

    root->midOrder(coutVisit);

    delete root;
}

void testBST()
{
    std::cout<<"testInitBST:\n";
    int n;
    std::cout<<"enter the number of Nodes and datas:\n";
    std::cin>>n;
    BST root = new BSTree();
    std::cin>>root->data;
    for (int i = 1; i < n; i++)
    {
        char data_;
        std::cin>>data_;
        root->insert(data_);
    }
    root->midOrder(coutVisit);//中序遍历展示

    std::cout<<"------------------------------\n";

    std::cout<<"try to find c\n";
    BST p = root->find('c');
    std::cout<<p->data<<std::endl;

    std::cout<<"------------------------------\n";

    std::cout<<"delete 'b':\n";
    root=root->delRecursion('b');
    std::cout<<"now is:\n";
    root->midOrder(coutVisit);
}
/*
输入如下：
9
b d e c f B C A D
*/

int main(){}

排序二叉树：