数据结构（十）、C++ 二叉排序树（BST）

已于 2022-12-22 10:39:18 修改
阅读量506 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
于 2022-11-23 14:09:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weijianjain/article/details/127999352
版权

二叉排序树

一、二叉排序树定义

  • 定义：二叉查找树，又被称为二叉搜索树。其特点如下：设x为二叉查找树中的一个结点，x节点包含关键字key，一句话就是左孩子比父节点小，右孩子比父节点大，还有一个特性就是”中序遍历“可以让结点有序。
        /*
                 (4)
                 /  \
               (2)   (6)
              /   \  /  \
            (1)  (3)(5) (8)
                          \
                          (9)
        */
  • 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  • 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  • 任意节点的左、右子树也分别为二叉搜索树；
  • 没有键值相等的节点。

二、二叉排序树插入操作

1、插入原理
  • 第一步：插入头节点(4)
        /*
                   (4)
        */
  • 第二步：插入节点(5)
    节点(5)的值比头节点（4）大，所以该节点插入到头节点（4）的右子树上
        /*
                   (4)
                      \
                       (5)
        */
  • 第三步：插入节点(3)
    节点(3)的值比头节点（4)小，所以该节点插入到头节点（4）的左子树上
        /*
                   (4)
                 /     \
              （3）     (5)
        */
  • 第四步：插入节点(7)
    节点(7)的值比头节点（4)大，由于头节点（4）的右子树上已有节点(5)，所以该节点与节点(5)比较，该节点（7）比节点(5)大，所以该节点插入到头节点（5）的右子树上
        /*
                   (4)
                 /     \
              （3）     (5)
                           \
                           (7)
        */
  • 依次类推插入
2、插入方式实现
  • 递归插入
        /**
         * @brief 插入
         * @param m_proot:树节点
         * @param m_pTdata:插入数据
         */
        node* insert(node* m_pRoot, T m_pData)
        {
            if (m_pRoot == nullptr)
                return new node(m_pData);
            if (m_pData < m_pRoot->m_data)
            {
                m_pRoot->m_left = insert(m_pRoot->m_left, m_pData);
            }
            else if (m_pData > m_pRoot->m_data)
            {
                m_pRoot->m_right = insert(m_pRoot->m_right, m_pData);
            }
            return m_pRoot;
        }
  • 非递归插入
//插入  （非递归）
        int BST_InsertLive(node*& m_pRoot, T m_pData)
        {
            node* temp = m_pRoot;            // 保存跟节点
            node* parent = nullptr;
            bool bLeftandRight = false;      // 记录循环找到空节点为左右子树那个
            while (temp != nullptr && temp->m_Tdata != m_pData)
            {
                parent = temp;
                if (m_pData < temp->m_Tdata)      // 左子树
                {
                    temp = temp->m_left;
                    bLeftandRight = false;
                }
                else if (m_pData > temp->m_Tdata) // 右子树
                {
                    temp = temp->m_right;
                    bLeftandRight = true;
                }
            }
            if (m_pRoot == nullptr)
            {
                m_pRoot = new node(m_pData);
                return 1;
            }
            else if (temp == nullptr)
            {
                if (!bLeftandRight)   // 左子树
                {
                    parent->m_left = new node(m_pData);
                }
                else                  // 右子树
                {
                    parent->m_right = new node(m_pData);
                }
                return 1;
            }
            else if (temp->m_Tdata == m_pData)
            {
                return 0;
            }
        }

三、二叉排序树删除操作

1、删除原理
  • 删除的节点为头节点直接删除
    删除头节点（4）
/*
      (4)    -->     
*/
  • 删除的节点左右子树都为空，直接删除节点
    删除节点（2）
        /*
                  (4)                       (4)
                  /  \         --->           \
                (2)  (5)                       (5)
        */
  • 删除的节点左子树为空
    删除节点（5），因为节点（5）的左子树为空，所有要删除节点（5），只需要将节点（5）的右子树（6）赋值给原来节点（5）的位置
        /*
                  (4)                       (4)
                  /  \         --->         /  \
                (2)  (5)                  (2)  (6)
                        \
                         (6)    
        */
  • 删除的节点右子树为空
    删除节点（6），因为节点（6）的右子树为空，所有要删除节点（6），只需要将节点（6）的左子树（5）赋值给原来节点（6）的位置
        /*
                  (4)                       (4)
                  /  \         --->         /  \
                (2)  (6)                  (2)  (5)
                     /   
                  (5)    
        */
  • 删除的节点左右子树都不为空
    删除的节点（5），其左右节点都不为空，由于二叉搜索树的特性是左子树一定小于右子树，所有节点（5）的右子树的值必然大于左子树的值，找到节点（5）的右子树的最小值，由于二叉搜索树的特性节点（5）的右子树的最小值必然大于节点（5）左子树的值，将节点（5）左子树赋值给节点（5）的右子树的最小值的左子树，然后删除节点（5），这样删除完成
        /*
              (1)                                  (1)
                 \                                    \
                  (5)            --->                  (6)
                 /   \                                /   
               (3)   (6)                            (3)   
              /                                    /
           (2)                                  (2)             
        */
2、C++递归实现
 /**
         * @brief 删除（leedcode题450）
         * @param m_proot:树节点
         * @param m_pTdata:删除值
         */
        node* remove(node* m_pRoot, T m_pTdata)
        {
            if (m_pRoot == nullptr)             // 节点为空
                return m_pRoot;
            if (m_pRoot->m_Tdata == m_pTdata)   // 找到该值的节点
            {
                if (m_pRoot->m_left == nullptr && m_pRoot->m_right == nullptr)      // 左右子树都为空，直接删除节点
                {
                    delete m_pRoot;
                    return nullptr;
                }
                else if (m_pRoot->m_left == nullptr)       // 左子树为空，删除左子树，返回右子树
                {
                    node* temp = m_pRoot->m_right;
                    delete m_pRoot;
                    return temp;
                }
                else if (m_pRoot->m_right == nullptr)     // 右子树为空，删除右子树，返回左子树
                {
                    node* temp = m_pRoot->m_left;
                    delete m_pRoot;
                    return temp;
                }
                else                                      // 左右子树都不为空
                {
                    node* curr = m_pRoot->m_right;        // 右子树赋值给节点curr
                    while (curr->m_left != nullptr)       // 循环找到m_pRoot右子树的最深左子树
                        curr = curr->m_left;
                    curr->m_left = m_pRoot->m_left;       // 将m_pRoot的左子树赋值给m_pRoot右子树的最深左子树
                    node* temp = m_pRoot;                 // 找到的节点m_pRoot赋值给节点temp
                    m_pRoot = m_pRoot->m_right;           // 节点m_pRoot的右子树赋值给节点m_pRoot
                    delete temp;
                    return m_pRoot;
                }
            }
            if (m_pRoot->m_Tdata > m_pTdata)
                m_pRoot->m_left = remove(m_pRoot->m_left, m_pTdata);
            if (m_pRoot->m_Tdata < m_pTdata)
                m_pRoot->m_right = remove(m_pRoot->m_right, m_pTdata);
            return m_pRoot;
        }

四、二叉排序树遍历操作

1、前序遍历

前序遍历：跟->左子树->右子树

        /*
                   (1)
                      \
                       (5)
                      /   \
                    (3)   (6)
                   /
                 (2)
           第一步：先访问跟节点（1）
           第二步：跟节点的左子树没有，访问右子树节点（5）
           第三步：访问节点（5）的左子树（3），再访问节点（3）的左子树（2）
           第四步：节点（2）没有左右子树，节点（3）没有右子树，访问节点（5）的右子树（6）
        */
  • 递归实现
        /**
         * @brief 前序遍历
         * @param m_proot:树节点
         */
        void print_Pre(node* m_proot)
        {
            if (m_proot != nullptr)
            {
                std::cout << m_proot->m_Tdata << " ";
                print_Pre(m_proot->m_left);
                print_Pre(m_proot->m_right);
            }
        }
  • 栈实现
        /**
         * @brief 前序遍历（栈实现）
         */
        void print_Pre_Stack()
        {
            if (m_root == nullptr)
                return;
            std::stack<node*> stStack;
            node* temp = m_root;
            while (temp != nullptr || !stStack.empty())
            {
                while (temp != nullptr)
                {
                    cout << temp->m_Tdata << " ";
                    stStack.push(temp);
                    temp = temp->m_left;
                }
                if (!stStack.empty())
                {
                    temp = stStack.top()->m_right;
                    stStack.pop();
                }
            }
            std::cout << std::endl;
        }
2、中序遍历

中序遍历：左子树->跟->右子树

        /*
                   (1)
                      \
                       (5)
                      /   \
                    (3)   (6)
                   /
                 (2)
           第一步：先访问跟节点（1）的左子树，再访问跟节点（1）
           第二步：访问节点（5）的左子树（3），节点（3）下面还有左子树，继续往下访问节点（3）的左子树（2）
           第三步：访问节点（3），然后访问节点（5），然后访问节点（5）的右子树（6）
        */
  • 递归实现
        /**
         * @brief 中序遍历
         * @param m_proot:树节点
         */
        void print_In(node* m_proot)
        {
            if (m_proot != nullptr)
            {
                print_In(m_proot->m_left);
                std::cout << m_proot->m_Tdata << " ";
                print_In(m_proot->m_right);
            }
        }
  • 栈实现
        /**
         * @brief 中序遍历（栈实现）
         */
        void print_In_Stack()
        {
            if (m_root == nullptr)
                return;
            std::stack<node*> stStack;
            node* temp = m_root;
            while (temp != nullptr || !stStack.empty())
            {
                while (temp != nullptr)
                {
                    stStack.push(temp);
                    temp = temp->m_left;
                }
                if (!stStack.empty())
                {
                    temp = stStack.top();
                    stStack.pop();
                    cout << temp->m_Tdata << " ";
                    temp = temp->m_right;
                }
            }
            std::cout << std::endl;
        }
3、后序遍历

后序遍历：左子树->右子树->跟

        /*
                   (1)
                      \
                       (5)
                      /   \
                    (3)   (6)
                   /
                 (2)
           第一步：先访问跟节点（1）的左子树，发现跟节点（1）没有左子树
           第二步：然后访问节点（1）的右子树（5），节点（5）下面还有左子树（3），继续往下访问节点（3）的左子树（2）
           第三步：访问节点（3），然后访问节点（5）的右子树（6），然后访问节点（5），
           第四步：最后访问跟节点（1）
        */
  • 递归实现
        /**
         * @brief 后序遍历
         * @param m_proot:树节点
         */
        void print_Post(node* m_proot)
        {
            if (m_proot != nullptr)
            {
                print_Post(m_proot->m_left);
                print_Post(m_proot->m_right);
                std::cout << m_proot->m_Tdata << " ";
            }
        }
  • 栈实现
        /**
         * @brief 后序遍历（栈实现）
         */
        void print_Post_Stack()
        {
            if (m_root == nullptr)
                return;
            std::stack<node*> stStack;
            node* temp = m_root;
            do
            {
                while (temp->m_left)
                {
                    stStack.push(temp);
                    temp = temp->m_left;
                }
                if (temp->m_right)
                {
                    stStack.push(temp);
                    temp = temp->m_right;
                }
                else
                {
                    while (!stStack.empty())
                    {
                        while (temp == stStack.top()->m_left && !stStack.top()->m_right ||
                            temp == stStack.top()->m_right && !stStack.top()->m_left)
                        {
                            std::cout << temp->m_Tdata << " ";
                            temp = stStack.top();
                            stStack.pop();
                            if (stStack.empty())
                                break;
                        }
                        std::cout << temp->m_Tdata << " ";
                        if (stStack.empty())
                            break;
                        if (temp == stStack.top()->m_left)
                        {
                            temp = stStack.top()->m_right;
                            break;
                        }
                        else
                        {
                            temp = stStack.top();
                            stStack.pop();
                            if (stStack.empty())
                                std::cout << temp->m_Tdata << " ";
                        }
                    }
                }
            } while (!stStack.empty());
            std::cout << std::endl;
        }
4、层次遍历
  • 队列实现
        /**
         * @brief 层次遍历（队列实现）
         */
        void print_Level_Queue()
        {
            if (m_root == nullptr)
                return;
            std::queue<node*> queQueue;
            node* temp = m_root;
            queQueue.push(temp);
            while (!queQueue.empty())
            {
                temp = queQueue.front();
                queQueue.pop();

                std::cout << temp->m_Tdata << " ";

                if (temp->m_left != nullptr)
                    queQueue.push(temp->m_left);
                if (temp->m_right != nullptr)
                    queQueue.push(temp->m_right);
            }
            std::cout << std::endl;
        }

五、整体代码

#include <iostream>
#include <stack>
#include <queue>

/**
 * @namespace 二叉排序树
 */
namespace tree_BST
{
    template<class T>
    class Tree
    {
    public:
        struct node
        {
            node(T m_pTdata) :m_Tdata(m_pTdata), m_left(nullptr), m_right(nullptr) {}
            T m_Tdata;
            node* m_left;    // 左子树  
            node* m_right;   // 右子树
        };

        Tree() :m_root(nullptr) {}

        /**
         * @brief 插入
         * @param m_pTdata:插入值
         */
        void insert(T m_pTdata)
        {
            m_root = insert(m_root, m_pTdata);
        }

        /**
         * @brief 删除
         * @param m_pTdata:删除值
         */
        void remove(T m_pTdata)
        {
            m_root = remove(m_root, m_pTdata);
        }

        /**
         * @brief 前序遍历
         */
        void print_Pre()
        {
            print_Pre(m_root);
            std::cout << std::endl;
        }

        /**
         * @brief 中序遍历
         */
        void print_In()
        {
            print_In(m_root);
            std::cout << std::endl;
        }

        /**
         * @brief 后序遍历
         */
        void print_Post()
        {
            print_Post(m_root);
            std::cout << std::endl;
        }

        /**
         * @brief 前序遍历（栈实现）
         */
        void print_Pre_Stack()
        {
            if (m_root == nullptr)
                return;
            std::stack<node*> stStack;
            node* temp = m_root;
            while (temp != nullptr || !stStack.empty())
            {
                while (temp != nullptr)
                {
                    cout << temp->m_Tdata << " ";
                    stStack.push(temp);
                    temp = temp->m_left;
                }
                if (!stStack.empty())
                {
                    temp = stStack.top()->m_right;
                    stStack.pop();
                }
            }
            std::cout << std::endl;
        }

        /**
         * @brief 中序遍历（栈实现）
         */
        void print_In_Stack()
        {
            if (m_root == nullptr)
                return;
            std::stack<node*> stStack;
            node* temp = m_root;
            while (temp != nullptr || !stStack.empty())
            {
                while (temp != nullptr)
                {
                    stStack.push(temp);
                    temp = temp->m_left;
                }
                if (!stStack.empty())
                {
                    temp = stStack.top();
                    stStack.pop();
                    cout << temp->m_Tdata << " ";
                    temp = temp->m_right;
                }
            }
            std::cout << std::endl;
        }

        /**
         * @brief 后序遍历（栈实现）
         */
        void print_Post_Stack()
        {
            if (m_root == nullptr)
                return;
            std::stack<node*> stStack;
            node* temp = m_root;
            do
            {
                while (temp->m_left)
                {
                    stStack.push(temp);
                    temp = temp->m_left;
                }
                if (temp->m_right)
                {
                    stStack.push(temp);
                    temp = temp->m_right;
                }
                else
                {
                    while (!stStack.empty())
                    {
                        while (temp == stStack.top()->m_left && !stStack.top()->m_right ||
                            temp == stStack.top()->m_right && !stStack.top()->m_left)
                        {
                            std::cout << temp->m_Tdata << " ";
                            temp = stStack.top();
                            stStack.pop();
                            if (stStack.empty())
                                break;
                        }
                        std::cout << temp->m_Tdata << " ";
                        if (stStack.empty())
                            break;
                        if (temp == stStack.top()->m_left)
                        {
                            temp = stStack.top()->m_right;
                            break;
                        }
                        else
                        {
                            temp = stStack.top();
                            stStack.pop();
                            if (stStack.empty())
                                std::cout << temp->m_Tdata << " ";
                        }
                    }
                }
            } while (!stStack.empty());
            std::cout << std::endl;
        }

        /**
         * @brief 层次遍历（队列实现）
         */
        void print_Level_Queue()
        {
            if (m_root == nullptr)
                return;
            std::queue<node*> queQueue;
            node* temp = m_root;
            queQueue.push(temp);
            while (!queQueue.empty())
            {
                temp = queQueue.front();
                queQueue.pop();

                std::cout << temp->m_Tdata << " ";

                if (temp->m_left != nullptr)
                    queQueue.push(temp->m_left);
                if (temp->m_right != nullptr)
                    queQueue.push(temp->m_right);
            }
            std::cout << std::endl;
        }

    private:
        /**
         * @brief 删除（leedcode题450）
         * @param m_proot:树节点
         * @param m_pTdata:删除值
         */
        node* remove(node* m_pRoot, T m_pTdata)
        {
            if (m_pRoot == nullptr)             // 节点为空
                return m_pRoot;
            if (m_pRoot->m_Tdata == m_pTdata)   // 找到该值的节点
            {
                if (m_pRoot->m_left == nullptr && m_pRoot->m_right == nullptr)      // 左右子树都为空，直接删除节点
                {
                    delete m_pRoot;
                    return nullptr;
                }
                else if (m_pRoot->m_left == nullptr)       // 左子树为空，删除左子树，返回右子树
                {
                    node* temp = m_pRoot->m_right;
                    delete m_pRoot;
                    return temp;
                }
                else if (m_pRoot->m_right == nullptr)     // 右子树为空，删除右子树，返回左子树
                {
                    node* temp = m_pRoot->m_left;
                    delete m_pRoot;
                    return temp;
                }
                else                                      // 左右子树都不为空
                {
                    node* curr = m_pRoot->m_right;        // 右子树赋值给节点curr
                    while (curr->m_left != nullptr)       // 循环找到m_pRoot右子树的最深左子树
                        curr = curr->m_left;
                    curr->m_left = m_pRoot->m_left;       // 将m_pRoot的左子树赋值给m_pRoot右子树的最深左子树
                    node* temp = m_pRoot;                 // 找到的节点m_pRoot赋值给节点temp
                    m_pRoot = m_pRoot->m_right;           // 节点m_pRoot的右子树赋值给节点m_pRoot
                    delete temp;
                    return m_pRoot;
                }
            }
            if (m_pRoot->m_Tdata > m_pTdata)
                m_pRoot->m_left = remove(m_pRoot->m_left, m_pTdata);
            if (m_pRoot->m_Tdata < m_pTdata)
                m_pRoot->m_right = remove(m_pRoot->m_right, m_pTdata);
            return m_pRoot;
        }

        /**
         * @brief 插入
         * @param m_proot:树节点
         * @param m_pTdata:插入数据
         */
        node* insert(node* m_pRoot, T m_pData)
        {
            if (m_pRoot == nullptr)
                return new node(m_pData);
            if (m_pData < m_pRoot->m_data)
            {
                m_pRoot->m_left = insert(m_pRoot->m_left, m_pData);
            }
            else if (m_pData > m_pRoot->m_data)
            {
                m_pRoot->m_right = insert(m_pRoot->m_right, m_pData);
            }
            return m_pRoot;
        }

        //插入  （非递归）
        int BST_InsertLive(node*& m_pRoot, T m_pData)
        {
            node* temp = m_pRoot;            // 保存跟节点
            node* parent = nullptr;
            bool bLeftandRight = false;      // 记录循环找到空节点为左右子树那个
            while (temp != nullptr && temp->m_Tdata != m_pData)
            {
                parent = temp;
                if (m_pData < temp->m_Tdata)      // 左子树
                {
                    temp = temp->m_left;
                    bLeftandRight = false;
                }
                else if (m_pData > temp->m_Tdata) // 右子树
                {
                    temp = temp->m_right;
                    bLeftandRight = true;
                }
            }
            if (m_pRoot == nullptr)
            {
                m_pRoot = new node(m_pData);
                return 1;
            }
            else if (temp == nullptr)
            {
                if (!bLeftandRight)   // 左子树
                {
                    parent->m_left = new node(m_pData);
                }
                else                  // 右子树
                {
                    parent->m_right = new node(m_pData);
                }
                return 1;
            }
            else if (temp->m_Tdata == m_pData)
            {
                return 0;
            }
        }
        /**
         * @brief 前序遍历
         * @param m_proot:树节点
         */
        void print_Pre(node* m_proot)
        {
            if (m_proot != nullptr)
            {
                std::cout << m_proot->m_Tdata << " ";
                print_Pre(m_proot->m_left);
                print_Pre(m_proot->m_right);
            }
        }


        /**
         * @brief 中序遍历
         * @param m_proot:树节点
         */
        void print_In(node* m_proot)
        {
            if (m_proot != nullptr)
            {
                print_In(m_proot->m_left);
                std::cout << m_proot->m_Tdata << " ";
                print_In(m_proot->m_right);
            }
        }

        /**
         * @brief 后序遍历
         * @param m_proot:树节点
         */
        void print_Post(node* m_proot)
        {
            if (m_proot != nullptr)
            {
                print_Post(m_proot->m_left);
                print_Post(m_proot->m_right);
                std::cout << m_proot->m_Tdata << " ";
            }
        }

    private:
        node* m_root;        // 根节点
    };

    void test_tree()
    {
        tree_BST::Tree<int> m_tree;
        std::cout << "BST insert(1,5,6,3,2)" << std::endl;
        m_tree.insert(1);
        /*
                   (1)
        */

        m_tree.insert(5);
        /*
                   (1)
                      \
                       (5)
        */

        m_tree.insert(6);
        /*
                   (1)
                      \
                       (5)
                          \
                           (6)
        */

        m_tree.insert(3);
        /*
                   (1)
                      \
                      (5)
                     /   \
                    (3)   (6)
        */

        m_tree.insert(2);
        /*
                   (1)
                      \
                       (5)
                      /   \
                    (3)   (6)
                   /
                 (2)
        */

        std::cout << "BST 前序遍历(跟->左子树->右子树):";
        m_tree.print_Pre();          // 1 5 3 2 6
        /*
                   (1)
                      \
                       (5)
                      /   \
                    (3)   (6)
                   /
                 (2)
           第一步：先访问跟节点（1）
           第二步：跟节点的左子树没有，访问右子树节点（5）
           第三步：访问节点（5）的左子树（3），再访问节点（3）的左子树（2）
           第四步：节点（2）没有左右子树，节点（3）没有右子树，访问节点（5）的右子树（6）
        */

        std::cout << "BST 中序遍历(左子树->跟->右子树):";
        m_tree.print_In();           // 1 2 3 5 6
        /*
                   (1)
                      \
                       (5)
                      /   \
                    (3)   (6)
                   /
                 (2)
           第一步：先访问跟节点（1）的左子树，再访问跟节点（1）
           第二步：访问节点（5）的左子树（3），节点（3）下面还有左子树，继续往下访问节点（3）的左子树（2）
           第三步：访问节点（3），然后访问节点（5），然后访问节点（5）的右子树（6）
        */

        std::cout << "BST 后序遍历(左子树->右子树->跟):";
        m_tree.print_Post();         // 2 3 6 5 1
        /*
                   (1)
                      \
                       (5)
                      /   \
                    (3)   (6)
                   /
                 (2)
           第一步：先访问跟节点（1）的左子树，发现跟节点（1）没有左子树
           第二步：然后访问节点（1）的右子树（5），节点（5）下面还有左子树（3），继续往下访问节点（3）的左子树（2）
           第三步：访问节点（3），然后访问节点（5）的右子树（6），然后访问节点（5），
           第四步：最后访问跟节点（1）
        */

        std::cout << "BST 前序遍历（栈实现）:";
        m_tree.print_Pre_Stack();    // 1 5 3 2 6

        std::cout << "BST 中序遍历（栈实现）:";
        m_tree.print_In_Stack();     // 1 2 3 5 6

        std::cout << "BST 后序遍历（栈实现）:";
        m_tree.print_Post_Stack();   // 2 3 6 5 1

        std::cout << "BST 层次遍历（队列实现）:";
        m_tree.print_Level_Queue();  // 1 5 3 6 2 

        std::cout << "BST 删除(3)（迭代实现）:";
        m_tree.remove(3);
        m_tree.print_In();           // 1 2 5 6
        /*
                   (1)             (1)
                      \               \
                       (5)            (5)
                      /   \          /   \
                    (3)   (6)      (2)   (6)
                   /
                (2)
         */

        std::cout << "BST 删除(2)（迭代实现）:";
        m_tree.remove(2);
        m_tree.print_In();           // 1 5 6

        std::cout << "BST 删除(1)（迭代实现）:";
        m_tree.remove(1);
        m_tree.print_In();           // 5 6

        std::cout << "BST 删除(6)（迭代实现）:";
        m_tree.remove(6);
        m_tree.print_In();           // 5

        std::cout << "BST 删除(5)（迭代实现）:";
        m_tree.remove(5);
        m_tree.print_In();           // 
    }

}// namespace tree_BST

int main()
{
    tree_BST::test_tree();
    return 0;
}
牛马不分
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树之二叉排序树基本操作（C++实现）
diviner_s的博客
05-10 1616
#include<iostream> using namespace std; #define N 10000 typedef int Status; // Status 相当于 int typedef int TElemType; //TElemType 相当于 int typedef struct BiTNode{ TElemType data; //结点数据域 stru
C++ 实现二叉排序树（二叉查找树）
qq_41220807的博客
06-15 3631
C++ 实现二叉排序树（二叉查找树） 二叉排序树( Binary Sort Tree)，又称为二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树。 若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值; 若它的右子树不空，则右子树上所有结点的值均大于宫的根结点的值; 它的左、右子树也分别为二叉排序树。 查找、插入与生成操作 #include <iostream&...
数据结构之二叉排序树（C++实现）
cheng_jack_li的博客
09-11 3178
二叉树是数据结构中的一个非常非常重要的板块，俗话说不到长城非好汉，那么不会二叉树就不算了解数据结构。什么是二叉树，在之前我们了解了链表，但是我们在使用的时候就会发现一个问题就是，链表的每一个节点只能在同一方向指向一个节点，也就是不能分叉，可是在实际应用中必须要有分叉的存在，怎么办呢，前辈们就提出了二叉排序树的概念。通过前边的学习我们了解了单链表有两个区域，就是数据域和指针域，双向链表为了实现反向遍历多加了一个区域叫前驱指针域，所以双向链表就有了三个域，前驱指针域，后继指针域和数据域，同理我们就能猜出来，二叉
【c++】二叉搜索树（BST）
Quietcoder的博客
05-13 1470
1.二叉搜索树的介绍🔥个人主页Quitecoder🔥c++笔记仓朋友们大家好，本篇文章来到二叉搜索树的内容。
C++进阶——二叉搜索树BST
weixin_43635473的博客
04-21 663
C++进阶——二叉搜索树BST
二叉树完整实现代码（C++）
Garen的博客
11-29 3261
为求方便节点存储数据类型默认为char，未以模板形式实现 #pragma once #include<iostream> #include<Stack> #include<Queue> using namespace std; //static int No=0; struct BNode { char data; BNode *lChild, *rChil...
基于C++的二叉排序树（免费提供源码）
最新发布
05-29
二叉排序树（Binary Search Tree, BST）作为一种重要的数据结构，因其高效的查找、插入和删除操作，被广泛应用于各种实际项目中。基于C++的二叉排序树项目旨在实现一个高性能、灵活且可扩展的二叉排序树系统，以便在...
数据结构课程设计_二叉排序树.doc
11-16
二叉排序树（Binary Sort Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键值，且左子树中的所有节点的键值都小于当前节点的键值，而右子树中的所有节点的键值都大于当前节点的键值。这种特性使得二叉...
《算法》使用C/C++语言实现二叉排序树
01-02
由于这些特点，二叉排序树通常用于实现动态集合的数据结构，可以高效地支持插入、删除和查找操作。在二叉排序树中，插入和查找操作的平均时间复杂度为O(log n)，其中n是树中结点的数量。然而，如果树的结构不平衡，...
数据结构课程设计_二叉排序树的实现.pdf
09-30
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树，是数据结构中的一种特殊类型，它满足以下性质：左子树上的所有节点的值都小于父节点的值，右子树上的所有节点的值都大于父节点的值。这样的结构使得在树中...
C++ BST（二叉搜索树）
a130737的专栏
07-19 2900
BST， 是一种完备二叉树。 顾名思义，
二叉排序树C++代码
12-17
二叉排序树C++代码 字符编码优化 传输 C++代码
C++ 二叉搜索树(BST)的实现方法
08-30
主要介绍了C++ 二叉搜索树(BST)的实现方法，非常不错，具有参考借鉴价值，需要的的朋友参考下
二叉排序树C++实现
08-10
二叉排序树的建立 搜索 插入 删除 遍历 等功能的实现 希望对你有所帮助
 二叉排序树c++代码及原理（插入、删除、查找、创建）
时间虚掷的孤岛
08-08 1927
二叉排序树 二叉排序树又称“二叉查找树”、“二叉搜索树”。 二叉排序树：或者是一棵空树，或者是具有下列性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 它的左、右子树也分别为二叉排序树。 二叉排序树通常采用二叉链表作为存储结构。中序遍历二叉排序树可得到一个依据关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即是对无序序列进行排序的过程。每次插入的.
C++ 不知树系列之二叉排序树（递归和非递归遍历、删除、插入……）
y6123236的专栏
11-04 1407
本文讲解了什么是二叉排序树，并深入地探讨在二叉排序树如何进行数据的插入、遍历、删除……
操作二叉排序树 c++
m0_74311500的博客
12-02 1775
一棵空树，或者是具有下列性质的二叉树：1、若左子树不空，则左子树上所有结点的值均。
二叉排序树C/C++代码实现
Ycy的博客
06-29 3075
二叉排序树(二叉查找树): 二叉排序树的一个重要性质：中序遍历一棵二叉 树时可以得到一个结点值递增的有序序列。 对于需要经常进行插入、 删除和查找运算的表，采用二叉排序树比较好 查找： 若二叉排序树为空，则查找失败，返回空指针。 若二叉排序树非空，将给定值key与根结点的关键字T->data.key进行比较： 1,若key等于T->data.key , 则查找成功,返回根结点地址； 2,若key小于T->data.key, 则递归查找左子树； 3,若key大于T->data.key
【C++】BST树（二叉搜索树）
weixin_56916549的博客
12-17 188
BST树（二叉搜索树）
二叉排序树BST的查找
11-03
二叉排序树BST的查找可以分为两种情况：一种是查找成功，一种是查找失败。查找成功的情况是指在BST中找到了目标值，查找失败的情况是指在BST中没有找到目标值。 查找成功的情况下，可以直接返回该节点；查找失败的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值