二叉查找树

#include <iostream>

using namespace std;

template <typename K, typename V>
class BST
{
    private:
        struct node    // 类内定义类、结构体
        {
            K key;
            V value;
            node *left = nullptr;
            node *right = nullptr; 
        };
        node * root = nullptr;
        node * putB(node *rootp, K key, V value);   // 注意不能把这个函数放在公有区，因为node是一个私有变量，如果外部调用putB会出问题，且只有成员函数会调用这个函数，没必要声明为公有的就不要声明为公有
    public:
        BST(/* args */);
        void putA(K key, V value);
        void putB(K key, V value);
        /* void putB(node *&rootp, K key, V value); */  //类内定义结构体不用加作用域限定：  BST<K, V>::node
        
        V get(K key);
        V getR(node *rootp, K key);     //对于结构相似且头尾相接的数据结构（如这里的二叉树：每个节点都可以是根节点，每个根节点下都有左右节点），要善于利用递归
        bool max(K &key, V &value);
        bool min(K &key, V &value);
        int rank(K key);
        bool remove(K key);
        int howMany();
        void show();
        void showR(node *p);
        void free(node *p);
        ~BST(); 
};

template <typename K, typename V>
BST<K, V>::BST(/* args */)
{
    //did nothing
}

template <typename K, typename V>
V BST<K, V>::get(K key)
{
    V val = NULL;
    val = getR(root, key);
    if(val != NULL)    //warning：val == 0  is equal to val == NULL
    {
        cout << "key: " << key << "	 val: " << val << endl;
        return val;
    }
}

template <typename K, typename V>
V BST<K, V>::getR(node *rootp, K key)
{
    if(rootp == nullptr)
    {
        cout << "can't find key[" << key << "]." << endl;
        return NULL;
    }
        
    if(rootp->key == key)
        return rootp->value;
    else if(rootp->key < key)
    {
        return getR(rootp->right, key);
    }
    else 
        return getR(rootp->left, key);
}

/* 循环查找 */
template <typename K, typename V>
void BST<K, V>::putA(K key, V value)
{
    node **temp = &root;    //使用指针的指针，因为下面要给指针分配内存
    while((*temp) != nullptr)
    {
        if((*temp)->key == key)
        {
            (*temp)->key = key;
            (*temp)->value = value;
            return;
        }
        if((*temp)->key > key)
            temp = &((*temp)->left);
        else 
            temp = &((*temp)->right);
    }
    *temp = (node *)new node;
    (*temp)->key = key;
    (*temp)->value = value;
}

template <typename K, typename V>
void BST<K, V>::putB(K key, V value)
{
    /* putB(root, key, value); */
    root = putB(root, key, value);
}

/* 递归查找 */
/* 
template <typename K, typename V>
void BST<K, V>::putB(node *&rootp, K key, V value)   //指针的引用
{
    if(rootp == nullptr)
    {
        rootp = new node;
        rootp->key = key;
        rootp->value = value;
        return;
    }
    if(rootp->key == key)
    {
        rootp->value = value;
        return;
    }
    else if(rootp->key > key)
        return putB(rootp->left, key, value);
    else
        return putB(rootp->right, key, value);
    
}
 */

/* 不加typename的话会提示错误： need 'typename' before 'BST<K, V>::node' because 'BST<K, V>' is a dependent scope，原因：c++primer P593 */
template <typename K, typename V>
typename BST<K, V>::node * BST<K, V>::putB(node *rootp, K key, V value)   
{
    if(rootp == nullptr)
    {
        rootp = new node;
        rootp->key = key;
        rootp->value = value;
        return rootp;
    }
    if(rootp->key == key)
    {
        rootp->value = value;
    }
    else if(rootp->key > key)
        rootp->left =  putB(rootp->left, key, value);
    else
        rootp->right = putB(rootp->right, key, value);

    return rootp;
}

template <typename K, typename V>
void BST<K, V>::show()
{
    showR(root);
}

template <typename K, typename V>
void BST<K, V>::showR(node *p)
{
    if(p->left != nullptr)
        showR(p->left);
    cout << "key: " << p->key << "	value: " << p->value << endl;
    if(p->right != nullptr)
        showR(p->right);
}

template <typename K, typename V>
void BST<K, V>::free(node *p)
{
    if(p == nullptr)
        return;
    free(p->left);
    free(p->right);
    delete p;
}

template <typename K, typename V>
BST<K, V>::~BST()
{
    free(root);
}

int main()
{
    BST<char, int> container;
    cout << "before: " << endl;
    for(int i=0; i<22; ++i)
    {
        char k = 65 + rand() % 20;
        int v = rand() % 100;
        cout << "k: " << k << "    v: " << v << endl;
        container.putB(k, v);
        //or container.putA(k, v);
    }
    
    container.show();

    char token;
    cout << "enter key you want to find(0 to exit):"; 
    cin >> token;
    while(token != '0')
    {
        container.get(token);
        cout << "enter key you want to find(0 to exit):";
        cin >> token;
    }
    
    return 0;
}