二叉搜索树-C++模板类

本文为二叉搜索树C++模板类的“学习”代码，其中含构造、析构、插入、中序遍历和删除等等。

#include <bits/stdc++.h>
using namespace std;

template <typename T>
struct TreeNode
{
    T val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(NULL), right(NULL) {}
    TreeNode(T x) : val(x), left(NULL), right(NULL) {}
};

template <typename T>
class BinaryserchT
{
private:
    TreeNode<T> *root;

    TreeNode<T> *insertNode(TreeNode<T> *node, T value);
    TreeNode<T> *removeNode(TreeNode<T> *node, T value);
    bool searchNode(TreeNode<T> *node, T value);
    void inorder(TreeNode<T> *node);

public:
    BinaryserchT() : root(NULL) {}
    ~BinaryserchT();
    void insert(T value)
    {
        root = insertNode(root, value);
    }
    void remove(T value)
    {
        root = removeNode(root, value);
    }
    bool search(T value)
    {
        return searchNode(root, value);
    }
    void inorderTrav()
    {
        inorder(root);
        cout << "\n";
    }
};

template <typename T>
BinaryserchT<T>::~BinaryserchT()
{
    while (root)
    {
        remove(root->val);
    }
}

template <typename T>
TreeNode<T> *BinaryserchT<T>::insertNode(TreeNode<T> *node, T value)
{
    if (node == NULL)
    {
        return new TreeNode<T>(value);
    }

    if (value < node->val)
    {
        node->left = insertNode(node->left, value);
    }
    else if (value > node->val)
    {
        node->right = insertNode(node->right, value);
    }
    return node;
}

template <typename T>
TreeNode<T> *BinaryserchT<T>::removeNode(TreeNode<T> *node, T value)
{
    if (node == NULL)
    {
        return NULL;
    }
    if (value < node->val)
    {
        node->left = removeNode(node->left, value);
    }
    else if (value > node->val)
    {
        node->right = removeNode(node->right, value);
    }
    else
    {
        if (node->left == NULL && node->right == NULL)
        {
            delete node;
            return NULL;
        }
        else if (node->left == NULL)
        {
            TreeNode<T> *rightchild = node->right;
            delete node;
            return rightchild;
        }
        else if (node->right == NULL)
        {
            TreeNode<T> *leftchild = node->left;
            delete node;
            return leftchild;
        }
        else
        {
            TreeNode<T> *replace = node->right;
            while (replace->left)
            {
                replace = replace->left;
            }
            node->val = replace->val;
            node->right = removeNode(node->right, replace->val);
        }
    }
    return node;
}

template <typename T>
bool BinaryserchT<T>::searchNode(TreeNode<T> *node, T value)
{
    if (node == NULL)
    {
        return false;
    }
    if (value < node->val)
    {
        return searchNode(node->left, value);
    }
    else if (value > node->val)
    {
        return searchNode(node->right, value);
    }
    return true;
}

template <typename T>
void BinaryserchT<T>::inorder(TreeNode<T> *node)
{
    if (node)
    {
        inorder(node->left);
        cout << node->val << "-";
        inorder(node->right);
    }
}

int main()
{
    BinaryserchT<int> bst;

    bst.insert(6);
    bst.insert(3);
    bst.insert(1);
    bst.insert(7);
    bst.insert(9);
    bst.insert(2);
    bst.insert(4);
    bst.insert(8);
    bst.insert(5);

    bst.inorderTrav();
    cout << bst.search(10) << "\n";
    cout << bst.search(9) << "\n";
    bst.remove(4);
    bst.inorderTrav();
    bst.insert(10);
    bst.inorderTrav();
    return 0;
}