【算法第四版 读书笔记】二叉搜索树

#include<iostream>
#include<exception>
using namespace std;


class NoAnswer : public exception {
public:
    const char* what()const throw() {
        return "NO ANSWER.\n";
    }
};


template<class Key, class Value>
class binarySearchTree {
private:
    struct TreeNode {
        Key key;
        Value val;
        TreeNode* left, * right;
        int N;
        TreeNode (const Key& k, const Value& v, TreeNode* l == nullptr, TreeNode* r = nullptr) : key(k), val(v), left(l), right(r) {}
    }
    TreeNode* root;
    int size(TreeNode* x)const;
    TreeNode& get(TreeNode* x, Key key)const;
    TreeNode& put(TreeNode* x, Key k, Value v);
    TreeNode& min(TreeNode* x)const;
    TreeNode& max(TreeNode* x)const;
    TreeNode& floor(TreeNode* x, Key k)const;
    TreeNode& ceil(TreeNode* x, Key k)const;
    TreeNode& select(TreeNode* x, int k)const;
    int rank(TreeNode* x, Key k)const;
    void delMin(TreeNode* x);
    void del(TreeNode* x, Key k);
public:
    int size()const { return size(root); }
    Value get(Key k)const { return get(root, k)->val; }
    void put(Key k, Value v) { root = put(root, k, v); }
    Key min()const { return min(root)->key; }
    Key max()const { return max(root)->key; }
    Key floor(Key k)const;
    Key ceil(Key k)const;
    Key select(int k)const { return select(root).key; }
    int rank(Key k)const { return rank(root, k); }
    void delMin() { root = delMin(root); }
    void del(Key k) { root = del(root, k); }
};


template<class Key, class Value>
int binarySearchTree<Key, Value>::size(TreeNode* x)const {
    if (x == nullptr) return 0;
    return x->N;
}

template<class Key, class Value>
TreeNode& binarySearchTree<Key, Value>::get(TreeNode* x, Key k)const {
    if (x == nullptr)  throw NoAnswer();
    
    if      (x->key < k) return get(x->right, k);
    else if (x->key > k) return get(x->left, k);
    else                 return x  ;
}

template<class Key, class Value>
TreeNode& binarySearchTree<Key, Value>::put(TreeNode* x, Key k, Value v) {
    if (x == nullptr)  return new TreeNode(k,v);

    if      (x->key < k) x->right = put(x->right, k, v);
    else if (x->key > k) x->left  = put(x->left, k, v);
    else                 x->val   = v;
    x->N = size(x->left) + size(x->right) + 1;
    return x;
}

template<class Key, class Value>
TreeNode& binarySearchTree<Key,Value>::min(TreeNode* x)const {
    TreeNode* tmp = x;
    while (tmp->left != nullptr) tmp = tmp->left;
    return tmp;
}

template<class Key, class Value>
TreeNode& binarySearchTree<Key,Value>::max(TreeNode* x)const {
    TreeNode* tmp = x;
    while (tmp->right != nullptr) tmp = tmp->right;
    return tmp;
}

template<class Key, class Value>
Key binarySearchTree<Key,Value>::floor(Key k)const {
    TreeNode* x = floor(root, k);
    if (x == nullptr) return nullptr;
    return x->key;
}

template<class Key, class Value>
Key binarySearchTree<Key,Value>::ceil(Key k)const {
    TreeNode* x = ceil(root, k);
    if (x == nullptr) return nullptr;
    return x->key;
}

template<class Key, class Value>
TreeNode& binarySearchTree<Key,Value>::floor(TreeNode* x, Key k)const {
    if (x == nullptr) return nullptr;
    if      (k == x.key) return x;
    else if (k < x.key)  return floor(x->left, key);
    TreeNode* t = floor(x->right, k);
    if (t != nullptr)  return t;
    return x;
}

template<class Key, class Value>
TreeNode& binarySearchTree<Key, Value>::ceil(TreeNode* x, Key k)const {
    if (x == nullptr) return nullptr;
    if      (k == x.key) return x;
    else if (k > x.key)  return ceil(x->right, key);
    TreeNode* t = ceil(x->left, k);
    if (t != nullptr) return t;
    return x;
}

template<class Key, class Value>
TreeNode& binarySearchTree<Key, Value>::select(TreeNode* x, int k) {
    if (x == nullptr) throw NoAnswer();

    int t = size(x->left);
    if      (t > k) return select(x->left, k);
    else if (t < k) return select(x->right, k-t-1);
    else            return x;
} 

template<class Key, class Value>
int binarySearchTree<Key, Value>::rank(TreeNode* x, Key k) {
    if (x == nullptr)  throw NoAnswer();
    if      (k < x->key) return rank(x->left, k);
    else if (k > x->key) return 1 + size(x->left) + rank(x->right, k);
    else                 return size(x->left);
}

template<class Key, class Value>
TreeNode& delMin(TreeNode* x) {
    if (x->left == nullptr) return x->right;
    x->left = delMin(x->left);
    x.N = size(x->left) + size(x->right) + 1;
    return x;
}

template<class Key, class Value>
TreeNode& del(TreeNode* x, Key k) {
    if (x == nullptr) return nullptr;
    if      (k < x.key) x->left = del(x->left, k);
    else if (k > x.key) x->right = del(x->right, k);
    else {
        if (x->right == nullptr) return x->left;
        if (x->left  == nullptr) return x->right;
        TreeNode* t = x;
        x = min(t->right);
        x->right = delMin(t->right);
        x->left = t->left;
    }
    x.N = size(x->left) + size(x->right) + 1;
    return x;
}