map和set的底层实现_map容器的底层实现-优快云博客

前言

map和set的底层都是由红黑树构成，但是map是kv模型，set是k模型。如何用一颗子树来同时封装map和set，还有怎么实现map/set的迭代器是这节重点

map和set的模板参数

struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
private:
		RBTree<K, pair<K, V>, MapKeyOfT> _t;

struct SetKeyOfT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
private:
		RBTree<K, K, SetKeyOfT> _t;

template<class K, class T, class KeyOfT>

我们通过在红黑树模板中增加一个KeyOfT参数，通过map和set的模板来识别是

map还是set

这样后面的数据就要通过KeyOfT形成的对象来比较大小了

如·：查找函数

//查找函数
iterator Find(const K& key)
{
	KeyOfT kot;
	Node* cur = _root;
	while (cur)
	{
		if (key < kot(cur->_data)) //key值小于该结点的值
		{
			cur = cur->_left; //在该结点的左子树当中查找
		}
		else if (key > kot(cur->_data)) //key值大于该结点的值
		{
			cur = cur->_right; //在该结点的右子树当中查找
		}
		else //找到了目标结点
		{
			return iterator(cur); //返回该结点
		}
	}
	return end(); //查找失败
}

迭代器

struct  _TreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef _TreeIterator<T,Ptr,Ref> Self;
	typedef _TreeIterator<T, T*, T&> iterator;
};
//构造函数
__TreeIterator(Node* node)
	:_node(node) //根据所给结点指针构造一个正向迭代器
{}

++运算符重载

1，右子树不为空，访问右子树的最左节点

2，右子树为空，找到该节点父亲，向上更新

Self& operator++()
    {
        if (_node->_right)
        {
            Node* min = _node;
            while (min)
            {
                min = min->_left;
            }
            _node = min;
        }
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            while (parent && parent->_right == cur)
            {
                cur = cur->_parent;
                parent = parent->_parent;
            }
            _node = parent;
        }
        return *this;
    }

--运算符重载

 Self& operator--()
    {
        if (_node->_left)
        {
            Node* max = _node->_left;
            while (max->_right)
            {
                max=max->_right
            }
            _node = max;
        }
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            if (parent&&cur == parent->_left)
            {
                cur = parent;
                parent = parent->_parent;
            }
            _node = parent;
        }
        return *this;
    }

迭代器总代码

template<class T,class Ref,class Ptr>
struct RBTreeIterator
{
    typedef RBTreeNode<T> Node;
    typedef RBTreeIterator<T,Ref, Ptr> Self;
    Node* _node;
    RBTreeIterator(Node* node)
        :_node(node)
    {}
    Ref operator*()
    {
        return _node->_data;
    }
    Ptr operator->()
    {
        return &_node->_data;
    
    }
   
    Self& operator++()
    {
        if (_node->_right)
        {
            Node* min = _node;
            while (min)
            {
                min = min->_left;
            }
            _node = min;
        }
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            while (parent && parent->_right == cur)
            {
                cur = cur->_parent;
                parent = parent->_parent;
            }
            _node = parent;
        }
        return *this;
    }
    bool operator!=(const Self& s) 
    {
        return _node != s._node;
    }
    bool operator==(const Self& s) const
    {
        return _node == s._node;
    }
    Self& operator--()
    {
        if (_node->_left)
        {
            Node* max = _node->_left;
            while (max->_right)
            {
                max=max->_right
            }
            _node = max;
        }
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            if (parent&&cur == parent->_left)
            {
                cur = parent;
                parent = parent->_parent;
            }
            _node = parent;
        }
        return *this;
    }
};

RBTree代码实现（重点更改部分）

begin()和end()

  typedef RBTreeIterator<T, T&, T*> iterator;
    iterator begin()
    {
        Node* min = _root;
        while (min&&min->_left)
        {
            min = min->_left;
        }
        return iterator(min);
    }
    iterator end()
    {
        return iterator(nullptr);
    }

构造函数/析构函数

RBTree()
        :_root(nullptr)
    {}
    ~RBTree()
    {
        Destory(root);
        _root = nullptr;
    }
    void Destory(Node* root)
    {
        if (root == nullptr)
        {
            return;
        }
        Destory(root->_left);
        Destory(root->_right);
        delete root;
    }

析构函数是递归进行删除的

拷贝构造/赋值重载

    RBTree<K, T, KeyOfT>& operator=(RBTree<K, T, KeyOfT> t)
    {
        swap(_root, t._root);
        return *this;
    }
    RBTRee(const RBTree<K, T, KeyOfT>& t)
    {
        _root = Copy(t._root);
    }
    void* Copy(Node* root)
    {
        if (root == nullptr)
        {
            return nullptr;
        }
        Node* newroot = new Node(*root);
        newroot->_col = root->_col;
        newroot->_left = Copy(root->_left);
        newroot->_right = Copy(root->_right);
        if (newroot->_left)
        {
            newroot->_left->_parent = newroot;
        }
        if (newroot->_right)
        {
            newroot->_right->_parent = newroot;
        }
        return newroot; 
    }

赋值重载利用现代写法

拷贝构造是递归进行拷贝的，由于只拷贝了节点，所以还要自己手动去链接父节点

插入函数的修改

插入函数修改成

  pair<iterator,bool> Insert(const T& data)

返回值为

 return make_pair(iterator(newnode), true);

、因为map中【】的本质就是调用insert函数，而【】在map中有多种功能：1：如果存在，返回value值2：如果不存在，则插入新节点

map/set都返回pair结构，其中map返回pair中的k值，set返回k值

set类

#pragma once

#include"RBTree.h"

namespace muyu
{

	template<class K>
	class set
	{
		struct SetofT
		{
			const K& operator()(const K& data)
			{
				return data;
			}
		};

	public:
		typedef typename RBTree<K, K, SetofT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetofT>::const_iterator const_iterator;


	public:
		pair<iterator, bool>& insert(const K& data)
		{
			pair<RBTree<K, K, SetofT>::iterator, bool> tem = _t.Insert(data);
			pair<iterator, bool> res = tem;
			return res;
		}

		iterator begin()const
		{
			return _t.begin();
		}

		iterator end()const
		{
			return _t.end();
		}

		iterator find(const K& key)
		{
			return _t.find(key);
		}

	private:
		RBTree<K, K, SetofT> _t;
	};
}

map类

#pragma once

#include"RBTree.h"

namespace muyu
{

	template<class K, class V>
	class map
	{
		struct MapofT
		{
			const K& operator()(const pair<K, V>& data)
			{
				return data.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapofT>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapofT>::const_iterator const_iterator;


	public:
		pair<iterator, bool> insert(const pair<K, V>& data)
		{
			return _t.Insert(data);
		}

		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		const_iterator begin()const
		{
			return _t.begin();
		}
		
		iterator find(const K& key)
		{
			return _t.find(key);
		}
		
		const_iterator end()const
		{
			return _t.end();
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}

	private:
		RBTree<K, pair<const K, V>, MapofT> _t;
	};
}