Set, скорость

#ifndef SET_H
#define SET_H
 
 
 
template <class T> struct SetElement
{
    T value;
    SetElement *left;
    SetElement *right;
};
 
template <class T> class Set
{
public:
    Set();
    Set(T value);
    int getCount() const;
    bool insert(T value);
    bool isInside(T value);
    bool remove(T value);
private:
    int count;
    SetElement<T> *top;
    bool add( SetElement<T> *&ptr, T value);
    bool del( SetElement<T> *&ptr, T value);
 
};
 
 
 
template <class T> Set<T>::Set(): count(0), top(NULL) {}
 
template <class T> Set<T>::Set(T value): count(1)
{
    top = new SetElement<T>();
    top -> left = NULL;
    top -> right = NULL;
    top -> value = value;
}
 
 
template <class T> int Set<T>::getCount() const
{
    return this -> count;
}
 
template <class T> bool Set<T>::insert(T value)
{
    return add(top, value);
}
 
 
template <class T> bool Set<T>::remove(T value)
{
    return del(top, value);
}
 
template <class T> bool Set<T>::add(SetElement<T> *&ptr, T value)
{
 
    if (ptr == NULL) {
        ptr = new SetElement<T>();
        ptr -> left = NULL;
        ptr -> right = NULL;
        ptr -> value = value;
        count++;
        return true;
    }
 
    if (value == ptr->value) {
        return false;
    }
 
    if (value < ptr->value) {
        return add(ptr->left, value);
    } else {
        return add(ptr->right, value);
    }
}
 
template <class T> bool Set<T>::isInside(T value)
{
 
    SetElement<T> *copy = top;
    while (copy != NULL) {
        if (copy -> value == value) {
            return true;
        } else
            if (value < copy -> value) {
                copy = copy -> left;
            } else {
                copy = copy -> right;
            }
    }
 
    return false;
 
}
 
template <class T> bool Set<T>::del(SetElement<T> *&ptr, T value)
{
    // no element
    if (ptr == NULL)
        return false;
 
 
    // if element with value exists in tree
    if (ptr -> value == value) {
 
        //if elements doesnt have a children
        if (ptr -> left == NULL && ptr -> right == NULL) {
            SetElement<T> *fake = ptr;
            ptr = NULL;
            delete fake;
            count--;
            return true;
        }
 
        //if exists left children
        if (ptr -> right == NULL) {
            SetElement<T> *fake = ptr;
            ptr = ptr -> left;
            delete fake;
            count--;
            return true;
        }
 
        //if exists right children
        if (ptr -> left == NULL) {
            SetElement<T> *fake = ptr;
            ptr = ptr -> left;
            delete fake;
            count--;
            return true;
        }
 
        // if exists both
        SetElement<T> *maxLeft = ptr -> left;
        while (maxLeft -> right != NULL) {
            maxLeft = maxLeft -> right;
        }
        ptr -> value = maxLeft ->value;
        del(ptr -> left, ptr -> value);
        return true;
    } else
        if (value < ptr -> value) {
            return del(ptr -> left, value);
        } else {
            return del(ptr -> right, value);
        }
 
}
 
 
#endif // SET_H

#include <iostream>
#include "set.h"
 
using namespace std;
 
int main()
{
 
    Set<int> myset;
 
    for (int i = 0; i < 10000; i++) {
        myset.insert(i);
    }
 
    return 0;
}
// result time = 0.831

#include <iostream>
#include <set>
 
using namespace std;
 
int main()
{
 
    set<int> myset;
 
    for (int i = 0; i < 10000; i++) {
        myset.insert(i);
    }
 
    return 0;
}
// result time = 0.031