BST 增删查操作 递归/非递归实现

约定：

        多次插入同一个key的节点，其value值取最后一次插入的值。

递归实现： 

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

class BST {
private:
    struct BSTNode {
        int key, value;
        BSTNode * left, *right;

        BSTNode (int _key, int _value, BSTNode * _left = nullptr, BSTNode * _right = nullptr) :
            left(_left), right(_right) {
            key = _key;
            value = _value;
        }
    };

    BSTNode * search(int key, BSTNode * root) {
        if (root==NULL) return NULL;
        if (root->key==key) return root;
        else if (root->key > key) return search(root->left, key);
        else return search(root->right, key);
    }
      
    BSTNode * insert(BSTNode * root, int key, int value) {
        if (root== NULL) 
            return new BSTNode (key, value);

        if (root->key == key) 
            root->value = value;
        else if (root->key < key) 
            root->right = insert(root->right, key, value);
        else 
            root->left = insert(root->left, key, value);

            return root;
    }

    BSTNode * removeAt(int key, BSTNode * root) {
         if (root == nullptr)
            return nullptr;

         if (key < root->key)
            root->left = removeAt(key, root->left);
         else if (root->key < key)
            root->right = removeAt(key, root->right);
         else {
            BSTNode * tmp;
            if (root->left && root->right) {
                tmp = findMax(root->left);
                root->key = tmp->key;
                root->value = tmp->value;
                root->left = removeAt(tmp->key, root->left);
            }
            else {
                tmp = root;
                if (root->left == nullptr)
                     root = root->right;
                else if (root->right == nullptr)
                     root = root->left;

                delete tmp;
             }
        }
        return root;
    }

    BSTNode * findMax(BSTNode * root) {
        if (root != nullptr) {
            while (root->right != nullptr)
                root = root->right;
        }

        return root;
    }

public:
    BSTNode * search(int key) {
        return search(key, Root);
    }

    void remove(int key) {
        Root = removeAt(key, Root);
    }

    void insert( int key, int value){
        Root = insert(Root, key, value);
    }
};

非递归实现：

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

class BST{
private:
    struct BSTNode {
        int key, value;
        BSTNode * left, *right;

        BSTNode (int _key, int _value, BSTNode * _left = nullptr, BSTNode * _right = nullptr) :
            left(_left), right(_right) {
            key = _key;
            value = _value;
        }
    };

    BSTNode *Root = nullptr, *ht = nullptr;

    BSTNode * search(int key, BSTNode * root) {
        ht = nullptr;
        while (root != nullptr) {
            if (root->key < key) {
                ht = root;
                root = root->right;
            }
            else if (key < root->key) {
                ht = root;
                root = root->left;
            }
            else
                return root;
        }

        return nullptr;
    }

    void removeAt(int key, BSTNode * root) {
        BSTNode * node = search(key);
        if (node != nullptr) {
            if (node->left == nullptr) {
                if (node == Root)
                    Root = node->right;
                else
                    (ht->key < node->key ? ht->right : ht->left) = node->right;
                delete node;
            }
            else if (node->right == nullptr) {
                if (node == Root)
                    Root = node->left;
                else
                    (ht->key < node->key ? ht->right : ht->left) = node->left;
                delete node;
            }
            else {
                BSTNode * p = node, *succ;
                succ = findMax(node->left, p);
                node->key = succ->key; node->value = succ->value;
                (p == node ? p->left : p->right) = succ->left;
                delete succ;
            }
        }
    }

    BSTNode * findMax(BSTNode * root, BSTNode * & ht) {
        if (root != nullptr) {
            while (root->right != nullptr) {
                ht = root;
                root = root->right;
            }
        }

        return root;
    }

public:
    BSTNode * search(int key) {
        return search(key, Root);
    }

    void insert(int key, int value) {
        BSTNode * tmp = search(key);
        if (tmp == nullptr) {//关键码不存在
            BSTNode * node = new BSTNode (key, value);
            if (ht == nullptr) {//根节点
                Root = node;
            }
            else {
                if (ht->key < key)
                    ht->right = node;
                else
                    ht->left = node;
            }
        }
        else
            tmp->value = value;
    }

    void remove(int key){
        removeAt(key,Root);
    }
};