从零开始写STL-二叉搜索树

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
平均情况下插入查找删除元素是Onlgn，最差情况下是On的

为什么要实现二叉搜索树？

由二叉搜索树发展来的红黑树是set/map的底层容器，为了学习的梯度我们先基于二叉搜索树来完成set和map。

二叉搜索树的结点设计

    template<typename T>
    struct BSnode
    {
        BSnode():left(nullptr),parent(nullptr),right(nullptr){}
        T data;
        struct BSnode* parent;
        struct BSnode* left;
        struct BSnode* right;
    };

二叉搜索树的迭代器设计

    template<typename T>
    class BStree_base_iterator : public bidirectional_iterator<T>
    {
    public:
        typedef BSnode<T>* ptr;
        ptr node;
        BStree_base_iterator()
        {
            node = nullptr;
        }
        BStree_base_iterator(ptr p)
        {
            node = p;
        }
        void increment()
        {
            if (node->right == nullptr)
            {
                ptr pre = node->parent;
                //回溯 在这里node==pre->right 等价于 node>pre
                while (pre != nullptr&&node == pre->right)
                {
                    node = pre;
                    pre = node->parent;
                }
                if (pre == nullptr)
                    node = nullptr;
                else
                    node = pre;
            }
            else//下一个结点是比自己大的结点（右子树）中最小的（最左）
            {
                node = node->right;
                while (node->left)
                    node = node->left;
            }
        }
        void decrement()
        {
            if (node->left == nullptr)
            {
                ptr pre = node->parent;
                while (pre != nullptr&&node == pre->left)
                {
                    node = pre;
                    pre = node->parent;
                }
                if (pre == nullptr)
                    node = nullptr;
                else
                    node = pre;
            }
            else
            {
                node = node->left;
                while (node->right)
                    node = node->right;
                //return node;
            }
        }
    };
    template<typename T>
    class BStree_iterator //加一层封装
    {
    public:
        typedef BSnode<T>* ptr;
        typedef  BStree_iterator<T> self;
        BStree_base_iterator<T> p;
        BStree_iterator()
        {
            p.node = nullptr;
        }
        BStree_iterator(ptr _p)
        {
            p.node = _p;
        }
        self& operator++(int)
        {
            p.increment();
            return *this;
        }
        self& operator--(int)
        {
            p.decrement();
            return *this;
        }
        bool operator!=(const  BStree_iterator<T>& rhs)
        {
            return !(*this == rhs);
        }
        bool operator==(const  BStree_iterator<T>& rhs)
        {
            return this->p.node == rhs.p.node;
        }
        T& operator*()
        {
            return p.node->data;
        }
        T& operator->()
        {
            return &(*this);
        }
    };

二叉搜索树源码

插入删除查找元素都可以利用和节点的值进行比较来递归查找，为了避免stackoverflow可以使用递归函数的非递归形式

    template<typename T >
    class BStree
    {
    public:
        typedef T value_type;
        typedef T* pointer;
        typedef size_t size_type;
        typedef BSnode<T>* node_ptr;
        typedef BStree<T> self;
        typedef BStree_iterator<T> iterator;
    private:
    //  Compare comparator;
        node_ptr node;
        size_t data_cnt;//元素个数
        std::allocator<BSnode<T>> data_allocator;
        node_ptr new_node(const value_type& val,node_ptr pre)//建立新节点
        {
            node_ptr p = data_allocator.allocate(1);
            new(&p->data) value_type(val);
            p->left = nullptr;
            p->right = nullptr;
            p->parent = pre;
            return p;
        }
        node_ptr insert_aux(node_ptr p, node_ptr pre,const value_type& val, node_ptr& ret)
        {
            while (p)
            {
                if (p->data == val) return p;
                pre = p;
                p = p->data > val ? p->left : p->right;
            }
            return new_node(val, pre);

            /* 递归版本 数目太多会stackoverflow
            if(!p)
            {
                return ret = new_node(val, pre);
            }
            if (p->data > val)
                p->left = insert_aux(p->left, p, val, ret);
            else if (p->data < val)
                p->right = insert_aux(p->right, p, val, ret);
            else
                ret = p;
            return p;*/
        }
        iterator find_aux(node_ptr p, const value_type& val)
        {
            while (p && p->data != val)
            {
                p = p->data > val ? p->left : p->right;
            }
            return iterator(p);
        }
        void del()
        {
            ministl::queue<node_ptr> q;
            q.push(node);
            while (!q.empty())
            {
                node_ptr p = q.front();
                q.pop();
                if (p->left)
                {
                    q.push(p->left);
                }
                if (p->right)
                {
                    q.push(p->right);
                }
                //删除之前保证左右子树入队 否则会有内存泄露
                delete p;
            }
            node = nullptr;
        }
        
        //删除操作，分四种情况
        //1. 左右子树为空，删除结点 并且将其父节点对应指针设置为空即可
        //2. 左子树空 右不空 删除结点 并且将其父节点对应指针设置为右子树即可
        //3. 左不空 右空  删除结点 并且将其父节点对应指针设置为左子树即可
        //4. 左右不空 找到左子树中值最大的元素 和结点元素交换
        void erase_aux(node_ptr p)
        {
            if (p->left == nullptr&&p->right == nullptr)
            {
                if (p->parent == nullptr)
                {
                    node = nullptr;
                }
                else if (p->parent->left!=nullptr && p->parent->left->data == p->data)
                    p->parent->left = nullptr;
                else if (p->parent->right!=nullptr && p->parent->right->data == p->data)
                    p->parent->right = nullptr;
                delete(p);
            }
            else if (p->left == nullptr&&p->right != nullptr)
            {
                if (p->parent == nullptr)
                {
                    node = p->right,node->parent = nullptr;
                }
                else if (p->parent->left!=nullptr && p->parent->left->data == p->data)
                    p->parent->left = p->right, p->right->parent = p->parent;
                else if (p->parent->right!=nullptr && p->parent->right->data == p->data)
                    p->parent->right = p->right, p->right->parent = p->parent;
                delete(p);
            }
            else if (p->left != nullptr&&p->right == nullptr)
            {
                if (p->parent == nullptr)
                {
                    node = p->left, node->parent = nullptr;
                }
                else if (p->parent->left!=nullptr && p->parent->left->data == p->data)
                    p->parent->left = p->left, p->left->parent = p->parent;
                else if (p->parent->right!=nullptr && p->parent->right->data == p->data)
                    p->parent->right = p->left, p->left->parent = p->parent;
                delete(p);
            }
            else
            {
                node_ptr it = p->left;
                node_ptr tmp = p;
                while (it->right != nullptr)
                {
                    tmp = it, it = it->right;
                }
                p->data = it->data;
                if (tmp != p)
                {
                    tmp->right = it->left;
                }
                else
                {
                    tmp->left = it->left;
                }
                if (it->left != nullptr)
                    it->left->parent = tmp;
                delete(it);
            }
        }
        iterator lower_bound_aux(node_ptr p, const value_type& x)
        {
            if (!p)
                return iterator(nullptr);
            if (p->data >= x)
            {
                auto tmp = lower_bound_aux(p->left, x);
                if (tmp.p.node != nullptr)
                    return tmp;
                else
                    return iterator(p);
            }
            else
                return lower_bound_aux(p->right, x);
        }
        iterator upper_bound_aux(node_ptr p, const value_type& x)
        {
            if (!p)
                return iterator(nullptr);
            if (p->data > x)
            {
                auto tmp = upper_bound_aux(p->left, x);
                if (tmp.p.node != nullptr)
                    return tmp;
                else
                    return iterator(p);
            }
            else
                return upper_bound_aux(p->right, x);
        }
        void erase_val_aux(node_ptr p,const value_type& key)
        {
            if (p == nullptr)
                return;
            if (p->data == key)
                erase_aux(p);
            else if (p->data < key)
                erase_val_aux(p->right, key);
            else if (p->data > key)
                erase_val_aux(p->left, key);
        }
    public:
        BStree() :node(nullptr),data_cnt(0) {}
        bool empty()
        {
            return node == nullptr;
        }
        size_type size()
        {
            return data_cnt;
        }
        iterator begin()
        {
            if (node == nullptr)
            {
                iterator t(nullptr);
                return t;
            }
            iterator it(node);
            while (it.p.node->left != nullptr)
                it.p.node = it.p.node->left;
            return it;
        }
        iterator end()
        {
            iterator it(nullptr);       
            return  (it);
        }
        iterator find_max()
        {
            node_ptr p = node;
            if (p == nullptr)
                return iterator(nullptr);
            while (p->right != nullptr)
                p = p->right;
            return iterator(p);
        }
        node_ptr root()
        {
            return node;
        }
        pair<iterator,bool> insert(const value_type& val)
        {
            node_ptr ret = nullptr;
            node = insert_aux(node, nullptr, val, ret);
            data_cnt++;
            return make_pair<iterator, bool>(ret , ret == nullptr);
        }
        iterator find(const value_type& key)
        {
            return find_aux(node, key);
        }
        iterator lower_bound(const value_type& x)
        {
            return lower_bound_aux(node, x);
        }
        iterator upper_bound(const value_type& x)
        {
            return upper_bound_aux(node, x);
        }
        void erase(iterator pos)
        {
            erase_aux(pos.p.node);
            data_cnt--;
        }
        void erase(const value_type& x)
        {
            erase_val_aux(node, x);
            data_cnt--;
        }
        void clear()
        {
            del();
            data_cnt = 0;
        }
    };

转载于:https://www.cnblogs.com/joeylee97/p/8664067.html