数据结构（十二）、C++ 反转二叉搜索树

（十二）、反转二叉搜索树

#include <iostream>
#include <queue>
/**
 * @namespace 反转二叉搜索树
 */
namespace tree_Reverse
{
    template<class T>
    class Tree
    {
    public:
        struct node
        {
            node(T data) :m_data(data), m_left(nullptr), m_right(nullptr) {}
            T m_data;
            node* m_left;
            node* m_right;
        };
        Tree() :m_root(nullptr) {}

        /**
         * @brief 插入
         */
        void insert(T m_pData)
        {
            m_root = insert(m_root, m_pData);
        }

        /**
         * @brief 反转
         */
        void reverse()
        {
            m_root = reverse(m_root);
        }


        /**
         * @brief 层次遍历（队列实现）
         */
        void print_level()
        {
            std::queue<node*> queTree;
            node* temp = m_root;
            queTree.push(temp);
            while (!queTree.empty())
            {
                temp = queTree.front();
                queTree.pop();
                std::cout << temp->m_data << " ";

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

    private:
        /**
         * @brief 插入
         */
        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;
        }

        /**
         * @brief 反转
         */
        node* reverse(node* m_pRoot)
        {
            if (m_pRoot == nullptr)
                return m_pRoot;
            node* temp = m_pRoot->m_left;
            m_pRoot->m_left = reverse(m_pRoot->m_right);
            m_pRoot->m_right = reverse(temp);
            return m_pRoot;
        }

    private:
        node* m_root;
    };

    void test_tree_Reverse()
    {
        tree_Reverse::Tree<int> m_tree;
        m_tree.insert(4);
        /*
              （4）       
        */

        m_tree.insert(6);
        /*
              （4） 
                 \
                 (6)
        */

        m_tree.insert(8);
        /*
              （4）
                 \
                 (6)
                   \
                   (8)
        */

        m_tree.insert(2);
        /*
              （4）
               / \
             (2) (6)
                   \
                   (8)
        */

        m_tree.insert(3);
        /*
              （4）
               / \
             (2) (6)
               \    \
               (3)  (8)
        */

        m_tree.insert(1);
        /*
              （4）
               / \
             (2) (6)
            /  \    \
          (1)  (3)  (8)
        */

        m_tree.insert(5);
        /*
              （4）
               / \
             (2)  (6)
            /  \   / \
          (1) (3)(5) (8)
        */

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

        std::cout << "Tree level（层次遍历）:";
        m_tree.print_level();        // 4 2 6 1 3 5 8 9

        std::cout << "Tree reverse（层次遍历）:";
        m_tree.reverse();
        m_tree.print_level();        // 4 6 2 8 5 3 1 9
        /*
                 (4)                           (4)
                 /  \                          /  \
               (2)   (6)         反转        (6)   (2)
              /   \  /  \       =====>      /   \  /  \
            (1)  (3)(5) (8)               (8)  (5)(3) (1)
                          \               /
                          (9)            (9)
        */
    }
}// namespace tree_Reverse
int main()
{
	tree_Reverse::test_tree_Reverse();
	return 0;
}