Question

我创建了二叉搜索树。我的函数可以添加，删除和查找带数字的节点。所有这些功能都运行良好。你能帮我两个功能： 1）打印BST 2）计算BST的深度？

我不知道如何以快速简便的方式做到这一点。深度我在添加新节点期间进行计算，但我希望仅具有执行该功能的功能。

class Node{
    public:
shared_ptr<Node> right;
shared_ptr<Node> left;
int number;
Node(int number)
{
    this->number=number;
    right=nullptr;
    left=nullptr;
}
~Node()
{
    cout<<"Deleted"<<" "<<number<<endl;
}
};
class BT
{
    public:
    shared_ptr<Node> root;
    int deep;
    BT(int num)
    {
      deep=0;
      root=make_shared<Node>(num);
    }

    void add_number(int num)
    {
        shared_ptr<Node> new_num=make_shared<Node>(num);
        shared_ptr<Node> tmp=root;
        int tmp_deep=0;
        while(tmp!=nullptr)
        {
            tmp_deep++;

            if(tmp->number>num)
            {
            if (tmp->left==nullptr)
            {
                tmp->left=new_num;
                break;
            }

            else
             tmp=tmp->left;
            }

            else if (tmp->number<num)
            {
                if (tmp->right==nullptr)
                 {
                tmp->right=new_num;
                break;
            }
            else
               tmp=tmp->right;
            }


        }
        tmp.reset();
        if (tmp_deep>deep)
            deep=tmp_deep;

    }

    shared_ptr<Node> find_node(int num)
    {
        shared_ptr<Node> tmp=root;

        while (tmp!=nullptr && tmp->number!=num)
        {
           if (tmp->number>num)
            tmp=tmp->left;
            else if (tmp->number<num)
                tmp=tmp->right;

        }

        if (tmp==nullptr)
        {
            cout<<"Not found";
            return nullptr;
        }
        else
            return tmp;

    }

    void delete_ (int num)
    {
        shared_ptr<Node> tmp=root;
        shared_ptr<Node> previous=root;


          while (tmp!=nullptr && tmp->number!=num)
        {
           if (tmp->number>num)
           {
               previous=tmp;
                tmp=tmp->left;

           }

            else if (tmp->number<num)
            {
                previous=tmp;
                tmp=tmp->right;
            }


        }

        if (tmp==nullptr)
        {
            cout<<"Not found";
        }
        else
        {

            if(tmp->left==nullptr && tmp->right==nullptr)
            {

                if (previous->number>tmp->number)
                previous->left=nullptr;
                else
                previous->right=nullptr;


                tmp.reset();
            }
            else if (tmp->left==nullptr && tmp->right!=nullptr)
            {
                if(tmp->right!=nullptr)
                {
                 previous->right=tmp->right;
                }
                else
                    previous->right=tmp->left;
                tmp.reset();
            }
            else if (tmp->left!=nullptr && tmp->right==nullptr)
            {
                if(tmp->right!=nullptr)
                {
                 previous->left=tmp->right;
                }
                else
                    previous->left=tmp->left;
                tmp.reset();
            }
            else if (tmp->left!=nullptr && tmp->right!=nullptr)
            {

                shared_ptr<Node> tmp_left=tmp->right;
                shared_ptr<Node> prev_left=tmp->right;
               while (tmp_left->left!=nullptr)
               {

                        //prev_left=tmp_left;
                        tmp_left=tmp_left->left;


                }
                if (tmp->number<previous->number)
                    previous->left=tmp_left;
                else
                    previous->right=tmp_left;

            prev_left->left=tmp_left->right;
            tmp_left->left=tmp->left;
            tmp_left->right=tmp->right;
            tmp.reset();

            }




        }

        void show_bt()
        {

        }
        void calc_depth()
        {

        }

    }




};

Answer 1

使用tree traversal可以完成计算深度和打印。此外，树遍历具有O(n)时间复杂度（n是树中节点的数量）。

PS：为了计算树深度，您可以使用三个traversal methods中的一个。

在每次递归调用中增加深度变量
之后减少它和
保存总最大值（减少前）

Answer 2

这个练习是每个程序员必须要做的，学习递归。这也可以通过迭代来完成，但这需要构建您的堆栈

对于递归，必须创建一个函数，该函数调用本身以“计算”结果。

您必须考虑如何从较小的结果中“计算”最终结果。

让我们看一下深度计算。

这是在一棵树上。这是从节点构建的。

那么我们如何计算节点上的某些东西以获得最终结果呢？

每个节点的高度都比（子树和右子树的）高度的最大值大1。如果没有子树，我们只会说它的高度为零。

顺便说一下：从不在一开始就寻找快捷方便。始终第一步是：让它发挥作用。

C ++二进制搜索树打印和深度计算

2 个答案: