map,set,multimap,multiset的异同

最新推荐文章于 2023-07-30 17:09:29 发布
最新推荐文章于 2023-07-30 17:09:29 发布
阅读量1.6k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 迭代器 map multiset multimap set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36221862/article/details/72808475
版权

map的特性是，所有元素都会依据元素的键值自动排序，map的所有元素都是键值对，同时有实值value和键值key。键值对的第一元素被视为键值，第二元素视为实值，map不允许两个元素有相同的实值。

注意：不可以通过map的迭代器改变map的元素值，因为set的元素值就是键值，关系到set的排列规则，如果任意改变set的元素值，会严重弄破坏set组织。如果想要修正元素的实值，答案是可以，因为map的元素的实值不影响map元素的排列规则，map迭代器既不是一种constant iterators,也不是一种mutable iterators
//map的底层实现--借助红黑树

#include <map>
#include<string>
#include<iostream>
using namespace std;



enum COLOR{RED, BLACK};

template<class K, class V>
struct RBTreeNode
{
    RBTreeNode(const K& key = K(), const V& value = V(), const COLOR& color = RED)
        : _pLeft(NULL)
        , _pRight(NULL)
        , _pParent(NULL)
        , _key(key)
        , _value(value)
        , _color(color)
    {}

    RBTreeNode<K, V>* _pLeft;
    RBTreeNode<K, V>* _pRight;
    RBTreeNode<K, V>* _pParent;
    K _key;
    V _value;
    COLOR _color;
};

template<class K, class V, class Ref, class Ptr>
class RBTreeIterator
{
    typedef RBTreeNode<K, V> Node;
    typedef RBTreeIterator<K, V, Ref, Ptr> Iterator;
public:
    RBTreeIterator()
        :_pNode(NULL)
    {}

    RBTreeIterator(Node* pNode)
        :_pNode(pNode)
    {}

    RBTreeIterator(const Iterator& s)
        :_pNode(s._pNode)
    {}

    Iterator& operator++()
    {
        Increment();
        return *this;
    }

    Iterator operator++(int)
    {
        Iterator temp(*this);
        Increment(_pNode);
        return temp;
    } 

    Iterator& operator--()
    {
        Decrement(_pNode);
        return *this;
    }

    Iterator operator--(int)
    {
        Iterator temp(*this);
        Decrement(_pNode);
        return temp;
    }

    Ref operator*()
    {
        return _pNode->_key;
    }

    Ptr operator->()
    {
        return &(operator*());
    }

    bool operator!=(const Iterator& s)
    {
        return _pNode != s._pNode;
    }

    bool operator==(const Iterator& s)
    {
        return !(*this != s);
    }

protected:
    Node* Increment()
    {
        Node* pNode = _pNode;
        // 如果当前节点的右子树存在，找右子树中最左边的结点
        if(pNode->_pRight)
        {
            pNode = pNode->_pRight;
            while(pNode->_pLeft)
                pNode = pNode->_pLeft;
        }
        else
        {
            Node* parent = pNode->_pParent;
            while(parent->_pRight == pNode)
            {
                pNode = parent;
                parent = pNode->_pParent;
            }
            // 特殊--> 根节点没有右子树，获取根节点的下一个结点
            //if(parent->parent != pNode)
            if(pNode->_pRight != parent)
                pNode = parent;
        }
        _pNode = pNode;
        return pNode;
    }

    Node* Decrement(Node* pNode)
    {
        if(pNode->_color == RED && pNode->_pParent->_pParent == pNode)
        {
            pNode = pNode->_pRight;
        }
        // 如果当前节点的左子树存在，找左子树中最右边的结点
        else if(pNode->_pLeft)
        {
            pNode = pNode->_pLeft;
            while(pNode->_pRight)
                pNode = pNode->_pRight;
        }
        else
        {
            Node* parent = pNode->_pParent;
            while(pNode->_pLeft == pNode)
            {
                pNode = parent;
                parent = pNode->_pParent;
            }
            pNode = parent;
        }
        _pNode = pNode;
        return pNode;
    }
private:
    Node* _pNode;
};

template<class K, class V>
class RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
    typedef RBTreeIterator<K, V, K&, K*> Iterator;
public:
    RBTree()
        :_size(0)
    {
        _pHead = new Node();
        _pHead->_pLeft = _pHead;
        _pHead->_pRight = _pHead;
        _pHead->_pParent = NULL;
        _pHead->_color = RED;
    }

    Iterator Begin()
    {
        return Iterator(_pHead->_pLeft);
    }

    Iterator End()
    {
        return Iterator(_pHead);
    }

    bool Empty()
    {
        return _pHead->_pParent == NULL;
    }

    size_t Size()
    {
        return _size;
    }

    Iterator Find(const K& key)
    {
        Node* pCur = _pHead->_pParent;
        while(pCur)
        {
            if(pCur->_key == key)
                return Iterator(pCur);
            else if(key < pCur->_key)
                pCur = pCur->_pLeft;
            else
                pCur = pCur->_pRight;
        }
        return Iterator(NULL);
    }

    bool Insert(const K& key, const V& value)
    {
        Node* _pRoot = _pHead->_pParent;
        //判断树是否存在
        if(_pRoot == NULL)
        {
            _pRoot = new Node(key, value, BLACK);
            _pHead->_pParent = _pRoot;
            _pRoot->_pParent = _pHead;

            return true;
        }
        else
        {
            //找插入位置
            Node* pCur = _pRoot;
            Node* parent = NULL;
            while(pCur)
            {
                if(key > pCur->_key)
                {
                    parent = pCur;
                    pCur = pCur->_pRight;
                }

                else if(key < pCur->_key)
                {
                    parent = pCur;
                    pCur = pCur->_pLeft;
                }

                else
                    return false;
            }
            //插入节点
            pCur = new Node(key, value);
            if(key > parent->_key)
                parent->_pRight = pCur;
            else
                parent->_pLeft = pCur;

            pCur->_pParent = parent;

            Node* pGrangFather = parent->_pParent;
            有可能违反红黑树性质
            while(pCur != _pRoot && parent->_color == RED)
            {
                //双亲的双亲一定存在，且为黑色
                if(parent == pGrangFather->_pLeft)
                {
                    Node* pUncle = pGrangFather->_pRight;
                    //情况一：pCur为红色，parent为红色，grand为黑色，uncle为红色
                    if(pUncle && pUncle->_color == RED )
                        //uncle存在且为红
                    {
                        parent->_color = BLACK;
                        pUncle->_color = BLACK;
                        pGrangFather->_color = RED;

                        pCur = pGrangFather;
                        parent = pGrangFather->_pParent;
                    }
                    //uncle不存在或者uncle存在且为黑色
                    else
                    {
                        //情况三：pCur为parent的右孩子
                        if(parent->_pRight == pCur)
                        {
                            _RotateL(parent);
                            swap(pCur, parent);
                        }

                        //情况二：pCur为parent的左孩子
                        parent->_color = BLACK;
                        pGrangFather->_color = RED;
                        _RotateR(pGrangFather);
                    }
                }
                else
                {
                    Node* pUncle = pGrangFather->_pLeft;
                    //情况一：uncle存在而且uncle为红色
                    if(pUncle && pUncle->_color == RED)
                    {
                        parent->_color = BLACK;
                        pUncle->_color = BLACK;
                        pGrangFather->_color = RED;

                        pCur = pGrangFather;
                        parent = pGrangFather->_pParent;
                    }
                    //uncle不存在或者uncle存在且为黑色
                    else
                    {
                        //情况三：pCur为parent的左孩子
                        if(pCur == parent->_pLeft)
                        {
                            _RotateR(parent);
                            swap(parent, pCur);
                        }

                        //情况二：pCur为parent的左孩子
                        parent->_color = BLACK;
                        pGrangFather->_color = RED;
                        _RotateL(pGrangFather);
                    }
                }
            }
            _pRoot->_color = BLACK;
            _pHead->_pParent = _pRoot;
            _pRoot->_pParent = _pHead;

        }
        _size++;
        _pHead->_pLeft = GetMinNode();
        _pHead->_pRight = GetMaxNode();
        return true;
    }

    void InOrder()
    {
        cout<<" InOrder: ";
        _InOrder(_pHead->_pParent);
        cout<<endl;
    }

    bool CheckRBTree()
    {
        //判断是否满足红黑树
        if(_pHead->_pParent == NULL)
            return true;

        if(_pHead->_pParent->_color == RED)
        {
            cout<<"根结点是红色的，不满足性质二"<<endl;
            return false;
        }

        size_t count = 0;
        Node* pCur = _pHead->_pParent;
        while (pCur)
        {
            if (pCur->_color == BLACK)
                count++;
            pCur = pCur->_pLeft;
        }//统计最左边路径上得黑色结点数

        size_t num = 0;

        return CheckColour(_pHead->_pParent) && _CheckRBTree(_pHead->_pParent, count, num);
    }


    bool CheckColour(Node* pRoot)
    {//检查颜色
        if (pRoot)
            return true;

        Node* parent = pRoot->_pParent;
        if (pRoot->_color == RED && parent->_color == RED)
        {
            cout<<"有两个连续的红色节点数，不满足性质3"<<endl;
            return false;
        }

        return CheckColour(pRoot->_pLeft) && CheckColour(pRoot->_pRight);
    }

protected:


    Node* GetMaxNode()
    {
        Node* pCur = _pHead->_pParent;
        while(pCur->_pRight)
            pCur = pCur->_pRight;

        return pCur;
    }

    Node* GetMinNode()
    {
        Node* pCur = _pHead->_pParent;
        while(pCur->_pLeft)
            pCur = pCur->_pLeft;

        return pCur;
    }

    void _RotateL(Node* parent)
    {
        Node* pSubR = parent->_pRight;
        Node* pSubRL = pSubR->_pLeft;

        parent->_pRight = pSubRL;
        if(pSubRL)
            pSubRL->_pParent = parent;

        pSubR->_pLeft = parent;
        Node* pparent = parent->_pParent;
        parent->_pParent = pSubR;
        pSubR->_pParent = pparent;

        if(pparent == NULL)
            _pHead->_pParent = pSubR;
        else
        {
            if(parent == pparent->_pLeft)
                pparent->_pLeft = pSubR;
            else
                pparent->_pRight = pSubR;
        }
    }

    void _RotateR(Node* parent)
    {
        Node* pSubL = parent->_pLeft;
        Node* pSubLR = pSubL->_pRight;

        parent->_pLeft = pSubLR;
        if(pSubLR)
            pSubLR->_pParent = parent;
        pSubL->_pRight = parent;
        Node* pparent = parent->_pParent;
        parent->_pParent = pSubL;
        pSubL->_pParent = pparent;
        if(pparent == NULL)
            _pHead->_pParent = pSubL;
        else
        {
            if(parent == pparent->_pLeft)
                pparent->_pLeft = pSubL;
            else
                pparent->_pRight = pSubL;
        }
    }

    void _InOrder(Node* pRoot)
    {
        if(pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout<<pRoot->_key<<" ";
            _InOrder(pRoot->_pRight);
        }
    }

    bool _CheckRBTree(Node* pRoot, const size_t blackCount, size_t k)
    {
        //检查黑色结点数目
        if (pRoot == NULL)
            return true;

        if (pRoot->_color == BLACK)
            ++k;

        if (pRoot->_pLeft == NULL && pRoot->_pRight == NULL && blackCount != k)
        {
            cout<<"每条路径上的黑色节点数不相等，不满足性质4"<<endl;
            return false;
        }

        return _CheckRBTree(pRoot->_pLeft, blackCount, k) && _CheckRBTree(pRoot->_pRight, blackCount, k);
    }

protected:
    Node* _pHead;
    size_t _size;
};


template<class K, class V>
class Map
{
public:
    typename typedef RBTreeIterator<K, V, K&, K*> Iterator;
public:
    Iterator Begin()
    {
        return t.Begin();
    }

    Iterator End()
    {
        return t.End();
    }

    bool Empty()const
    {
        return t.Empty();
    }

    bool Insert(const K& key, const V& value)
    {
        return t.Insert(key, value);
    }

    size_t Size()const
    {
        return t.Size();
    }

    Iterator Find(const K& key)
    {
        return t.Find(key);
    }


    bool operator != (const Iterator& s)
    {
        return _pNode != s._pNode;
    }

    bool operator == (const Iterator& s)
    {
        return !(*this != s);
    }

    V& operator[](const K& key)
    {
        Iterator it = t.Find(key);
        return (it._pNode)->_value;
    }

private:
    RBTree<K, V> t;
};

set的特性是，所有元素都会依据元素的键值自动排序，set 的所有元素就是实值，实值就是键值。set不允许两个元素有相同的实值。

注意：不可以通过set的迭代器改变set的元素值，因为set的元素值就是键值，关系到set的排列规则，如果任意改变set的元素值，会严重弄破坏set组织。set迭代器是一种constant iterators.


#include <set>
#include<string>
#include<iostream>
using namespace std;



enum COLOR{RED, BLACK};

template<class K, class V>
struct RBTreeNode
{
    RBTreeNode(const K& key = K(), const V& value = V(), const COLOR& color = RED)
        : _pLeft(NULL)
        , _pRight(NULL)
        , _pParent(NULL)
        , _key(key)
        , _value(value)
        , _color(color)
    {}

    RBTreeNode<K, V>* _pLeft;
    RBTreeNode<K, V>* _pRight;
    RBTreeNode<K, V>* _pParent;
    K _key;
    V _value;
    COLOR _color;
};

template<class K, class V, class Ref, class Ptr>
class RBTreeIterator
{
    typedef RBTreeNode<K, V> Node;
    typedef RBTreeIterator<K, V, Ref, Ptr> Iterator;
public:
    RBTreeIterator()
        :_pNode(NULL)
    {}

    RBTreeIterator(Node* pNode)
        :_pNode(pNode)
    {}

    RBTreeIterator(const Iterator& s)
        :_pNode(s._pNode)
    {}

    Iterator& operator++()
    {
        Increment();
        return *this;
    }

    Iterator operator++(int)
    {
        Iterator temp(*this);
        Increment(_pNode);
        return temp;
    } 

    Iterator& operator--()
    {
        Decrement(_pNode);
        return *this;
    }

    Iterator operator--(int)
    {
        Iterator temp(*this);
        Decrement(_pNode);
        return temp;
    }

    Ref operator*()
    {
        return _pNode->_key;
    }

    Ptr operator->()
    {
        return &(operator*());
    }

    bool operator!=(const Iterator& s)
    {
        return _pNode != s._pNode;
    }

    bool operator==(const Iterator& s)
    {
        return !(*this != s);
    }

protected:
    Node* Increment()
    {
        Node* pNode = _pNode;
        // 如果当前节点的右子树存在，找右子树中最左边的结点
        if(pNode->_pRight)
        {
            pNode = pNode->_pRight;
            while(pNode->_pLeft)
                pNode = pNode->_pLeft;
        }
        else
        {
            Node* parent = pNode->_pParent;
            while(parent->_pRight == pNode)
            {
                pNode = parent;
                parent = pNode->_pParent;
            }
            // 特殊--> 根节点没有右子树，获取根节点的下一个结点
            //if(parent->parent != pNode)
            if(pNode->_pRight != parent)
                pNode = parent;
        }
        _pNode = pNode;
        return pNode;
    }

    Node* Decrement(Node* pNode)
    {
        if(pNode->_color == RED && pNode->_pParent->_pParent == pNode)
        {
            pNode = pNode->_pRight;
        }
        // 如果当前节点的左子树存在，找左子树中最右边的结点
        else if(pNode->_pLeft)
        {
            pNode = pNode->_pLeft;
            while(pNode->_pRight)
                pNode = pNode->_pRight;
        }
        else
        {
            Node* parent = pNode->_pParent;
            while(pNode->_pLeft == pNode)
            {
                pNode = parent;
                parent = pNode->_pParent;
            }
            pNode = parent;
        }
        _pNode = pNode;
        return pNode;
    }
private:
    Node* _pNode;
};

template<class K, class V>
class RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
    typedef RBTreeIterator<K, V, K&, K*> Iterator;
public:
    RBTree()
        :_size(0)
    {
        _pHead = new Node();
        _pHead->_pLeft = _pHead;
        _pHead->_pRight = _pHead;
        _pHead->_pParent = NULL;
        _pHead->_color = RED;
    }

    Iterator Begin()
    {
        return Iterator(_pHead->_pLeft);
    }

    Iterator End()
    {
        return Iterator(_pHead);
    }

    bool Empty()
    {
        return _pHead->_pParent == NULL;
    }

    size_t Size()
    {
        return _size;
    }

    Iterator Find(const K& key)
    {
        Node* pCur = _pHead->_pParent;
        while(pCur)
        {
            if(pCur->_key == key)
                return Iterator(pCur);
            else if(key < pCur->_key)
                pCur = pCur->_pLeft;
            else
                pCur = pCur->_pRight;
        }
        return Iterator(NULL);
    }

    bool Insert(const K& key, const V& value = V())
    {
        Node* _pRoot = _pHead->_pParent;
        //判断树是否存在
        if(_pRoot == NULL)
        {
            _pRoot = new Node(key, value, BLACK);
            _pHead->_pParent = _pRoot;
            _pRoot->_pParent = _pHead;

            return true;
        }
        else
        {
            //找插入位置
            Node* pCur = _pRoot;
            Node* parent = NULL;
            while(pCur)
            {
                if(key > pCur->_key)
                {
                    parent = pCur;
                    pCur = pCur->_pRight;
                }

                else if(key < pCur->_key)
                {
                    parent = pCur;
                    pCur = pCur->_pLeft;
                }

                else
                    return false;
            }
            //插入节点
            pCur = new Node(key, value);
            if(key > parent->_key)
                parent->_pRight = pCur;
            else
                parent->_pLeft = pCur;

            pCur->_pParent = parent;

            Node* pGrangFather = parent->_pParent;
            有可能违反红黑树性质
            while(pCur != _pRoot && parent->_color == RED)
            {
                //双亲的双亲一定存在，且为黑色
                if(parent == pGrangFather->_pLeft)
                {
                    Node* pUncle = pGrangFather->_pRight;
                    //情况一：pCur为红色，parent为红色，grand为黑色，uncle为红色
                    if(pUncle && pUncle->_color == RED )
                        //uncle存在且为红
                    {
                        parent->_color = BLACK;
                        pUncle->_color = BLACK;
                        pGrangFather->_color = RED;

                        pCur = pGrangFather;
                        parent = pGrangFather->_pParent;
                    }
                    //uncle不存在或者uncle存在且为黑色
                    else
                    {
                        //情况三：pCur为parent的右孩子
                        if(parent->_pRight == pCur)
                        {
                            _RotateL(parent);
                            swap(pCur, parent);
                        }

                        //情况二：pCur为parent的左孩子
                        parent->_color = BLACK;
                        pGrangFather->_color = RED;
                        _RotateR(pGrangFather);
                    }
                }
                else
                {
                    Node* pUncle = pGrangFather->_pLeft;
                    //情况一：uncle存在而且uncle为红色
                    if(pUncle && pUncle->_color == RED)
                    {
                        parent->_color = BLACK;
                        pUncle->_color = BLACK;
                        pGrangFather->_color = RED;

                        pCur = pGrangFather;
                        parent = pGrangFather->_pParent;
                    }
                    //uncle不存在或者uncle存在且为黑色
                    else
                    {
                        //情况三：pCur为parent的左孩子
                        if(pCur == parent->_pLeft)
                        {
                            _RotateR(parent);
                            swap(parent, pCur);
                        }

                        //情况二：pCur为parent的左孩子
                        parent->_color = BLACK;
                        pGrangFather->_color = RED;
                        _RotateL(pGrangFather);
                    }
                }
            }
            _pRoot->_color = BLACK;
            _pHead->_pParent = _pRoot;
            _pRoot->_pParent = _pHead;

        }
        _size++;
        _pHead->_pLeft = GetMinNode();
        _pHead->_pRight = GetMaxNode();
        return true;
    }

    void InOrder()
    {
        cout<<" InOrder: ";
        _InOrder(_pHead->_pParent);
        cout<<endl;
    }

    bool CheckRBTree()
    {
        //判断是否满足红黑树
        if(_pHead->_pParent == NULL)
            return true;

        if(_pHead->_pParent->_color == RED)
        {
            cout<<"根结点是红色的，不满足性质二"<<endl;
            return false;
        }

        size_t count = 0;
        Node* pCur = _pHead->_pParent;
        while (pCur)
        {
            if (pCur->_color == BLACK)
                count++;
            pCur = pCur->_pLeft;
        }//统计最左边路径上得黑色结点数

        size_t num = 0;

        return CheckColour(_pHead->_pParent) && _CheckRBTree(_pHead->_pParent, count, num);
    }


    bool CheckColour(Node* pRoot)
    {//检查颜色
        if (pRoot)
            return true;

        Node* parent = pRoot->_pParent;
        if (pRoot->_color == RED && parent->_color == RED)
        {
            cout<<"有两个连续的红色节点数，不满足性质3"<<endl;
            return false;
        }

        return CheckColour(pRoot->_pLeft) && CheckColour(pRoot->_pRight);
    }

protected:


    Node* GetMaxNode()
    {
        Node* pCur = _pHead->_pParent;
        while(pCur->_pRight)
            pCur = pCur->_pRight;

        return pCur;
    }

    Node* GetMinNode()
    {
        Node* pCur = _pHead->_pParent;
        while(pCur->_pLeft)
            pCur = pCur->_pLeft;

        return pCur;
    }

    void _RotateL(Node* parent)
    {
        Node* pSubR = parent->_pRight;
        Node* pSubRL = pSubR->_pLeft;

        parent->_pRight = pSubRL;
        if(pSubRL)
            pSubRL->_pParent = parent;

        pSubR->_pLeft = parent;
        Node* pparent = parent->_pParent;
        parent->_pParent = pSubR;
        pSubR->_pParent = pparent;

        if(pparent == NULL)
            _pHead->_pParent = pSubR;
        else
        {
            if(parent == pparent->_pLeft)
                pparent->_pLeft = pSubR;
            else
                pparent->_pRight = pSubR;
        }
    }

    void _RotateR(Node* parent)
    {
        Node* pSubL = parent->_pLeft;
        Node* pSubLR = pSubL->_pRight;

        parent->_pLeft = pSubLR;
        if(pSubLR)
            pSubLR->_pParent = parent;
        pSubL->_pRight = parent;
        Node* pparent = parent->_pParent;
        parent->_pParent = pSubL;
        pSubL->_pParent = pparent;
        if(pparent == NULL)
            _pHead->_pParent = pSubL;
        else
        {
            if(parent == pparent->_pLeft)
                pparent->_pLeft = pSubL;
            else
                pparent->_pRight = pSubL;
        }
    }

    void _InOrder(Node* pRoot)
    {
        if(pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout<<pRoot->_key<<" ";
            _InOrder(pRoot->_pRight);
        }
    }

    bool _CheckRBTree(Node* pRoot, const size_t blackCount, size_t k)
    {
        //检查黑色结点数目
        if (pRoot == NULL)
            return true;

        if (pRoot->_color == BLACK)
            ++k;

        if (pRoot->_pLeft == NULL && pRoot->_pRight == NULL && blackCount != k)
        {
            cout<<"每条路径上的黑色节点数不相等，不满足性质4"<<endl;
            return false;
        }

        return _CheckRBTree(pRoot->_pLeft, blackCount, k) && _CheckRBTree(pRoot->_pRight, blackCount, k);
    }

protected:
    Node* _pHead;
    size_t _size;
};


template<class K>
class Set
{
public:
    typename typedef RBTreeIterator<K, K, K&, K*> Iterator;
public:
    Iterator Begin()
    {
        return t.Begin();
    }

    Iterator End()
    {
        return t.End();
    }

    bool Empty()const
    {
        return t.Empty();
    }

    bool Insert(const K& key)
    {
        return t.Insert(key);
    }

    size_t Size()const
    {
        return t.Size();
    }

    Iterator Find(const K& key)
    {
        return t.Find(key);
    }


    bool operator != (const Iterator& s)
    {
        return _pNode != s._pNode;
    }

    bool operator == (const Iterator& s)
    {
        return !(*this != s);
    }

    K& operator[](const K& key)
    {
        Iterator it = t.Find(key);
        return (it._pNode)->_key;
    }

private:
    RBTree<K, K> t;
};

multiset的特性以及用法和set完全相同，唯一的差别在于它允许键值重复，因此他的操作采用的是底层机制RB-tree的insert-equal()

multimap的特性以及用法和map完全相同，唯一的差别在于它允许键值重复，因此他的操作采用的是底层机制RB-tree的insert-equal()

摩天轮的思念
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
multiset用法总结
二喵君的博客
12-04 10万+
       c++语言中，multiset是&lt;set&gt;库中一个非常有用的类型，它可以看成一个序列，插入一个数，删除一个数都能够在O(logn)的时间内完成，而且他能时刻保证序列中的数是有序的，而且序列中可以存在重复的数。 简单应用： 通过一个程序来看如何使用multiset： #include &lt;string&gt; #include &lt;iostream&gt; ...
multiset的介绍及使用
热门推荐
gp1330782530的博客
05-28 1万+
multiset的介绍及使用 1、multiset的介绍 1、multiset是按照特定顺序存储元素的容器，其中元素是可以重复的 2、在multiset在，元素的value也会识别它组成的键值对，multiset元素的值不能在容器中进行修改，但可以插入和删除 3、在内部，multiset按照特定的严格弱排序准则进行排序 4、multiset容器通过key访问单个元素比unordered_multiset容器慢，但当使用迭代器遍历的时候，会得到一个有序序列 5、multiset的底层是二叉搜索树（红黑树）
C++进阶 —— multiset
NapoleonCoder的博客
12-08 1557
关联式容器multiset；
oracle中multiset,在POSTGRES中可以使用Oracle Cast和MULTISET
weixin_33509600的博客
04-03 195
我一直在研究从oracle数据库数据库生成xml的查询其中“列”是一种类型CREATE OR REPLACE TYPE "column" AS OBJECT("coulmnname" VARCHAR2 (30), "datatype" VARCHAR2 (30))和col_list_t是类型CREATE OR REPLACE TYPE col_list_t AS TABLE OF "column"...
multiset和set，map和multimap的区别
github_38595636的博客
03-14 2316
一、set和multiset的差异和相同 set是一个集合容器，其中所包含的元素是唯一的，集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。 set采用红黑树变体的数据结构实现，红黑树属于平衡二叉树。在插入操作和删除操作上比vector快。 set不可以直接存取元素。（不可以使用at.(pos)与[]操作符）。 multiset与set的区别：set支持唯一键值，每个元素值只能出现一次；而multiset中同一值可以出现多次。 不可以直接修改set或multiset
C++ STL入门教程(7) multimap、multiset的使用
08-29
C++ STL入门教程(7) multimap、multiset的使用 本文主要介绍了C++ STL中multimap和multiset的使用方法，multimap是一对多索引，multiset是多元集合，都是STL容器中非常重要的组件。 一、multimap(一对多索引) ...
AVL_Tree实现STL中的map, set, multimap和multiset
01-10
用AVL-tree数据结构作为底层机制，以STL底层空间配置器和iterator_traits编程技法实作出一个独立的关联式容器(map, set, multimap, multiset)，并对外提供接口实现和STL完全兼容的容器。
C++模板（vector、map、multimap、set、multiset）
08-05
在C++标准库中，模板被广泛应用于STL（Standard Template Library，标准模板库），其中包括了各种容器如vector、map、multimap、set和multiset。这些容器都是模板类，它们提供了高效的数据组织和操作方式。 1. **...
map/multimap属于**关联式容器**，底层结构是用二叉树实现
10-16
在STL中，`map`和`multimap`就是这样的关联式容器。这两个容器都是基于**红黑树**这种自平衡二叉查找树的数据结构来实现的，保证了在平均情况下，查找、插入和删除操作的时间复杂度为O(log n)。 **map**容器： `map...
【C++ STL】set/multiset 容器存储结构及常用成员方法操作
qq_46403377的博客
07-30 885
使用 set 当你需要一个容器存储唯一元素，且不允许重复。使用 multiset 当你需要一个容器存储元素，允许重复，并按照升序排序。在选择使用 set 还是 multiset 时，根据你的需求来决定是否允许重复元素。
C++——set/multiset再理解
m0_49687898的博客
06-14 330
1. 关联式容器 2. 键值对 3. 树形结构的关联式容器 4. set容器 4.1 set的介绍 4.2 set的使用 5. multiset 5.1multiset的介绍 5.2 mutiset的使用
STL之multiset简介
weixin_33915554的博客
09-27 272
2019独角兽企业重金招聘Python工程师标准>>> ...
STL总结之multiset
YangLei253的博客
07-28 1034
介绍 multiset 是一个封装红黑树 (自平衡二叉树) 的关联容器，其中元素依据其值自动排序且每个元素可出现任意次。 multiset 定义于头文件 <set> 中，其声明如下： template< class Key, class Compare = std::less<Key>, class Allocator = std::alloc...
set,multiset,map,multimap的区别 和基本的使用
qq_44065088的博客
10-16 242
#include <iostream> #include <set> #include <Windows.h> #include <string> #include <map> using namespace std; int main(void) { //值域 不重复 set set<int> ...
map和multimap 详解
weixin_30293079的博客
05-25 721
概况 Map和Multimap是将key/value pair 当做元素，进行管理。可以根据key的排序准则自动将元素排序。multimap允许重复元素，map不允许有重复，如图1所示。 图1 Maps和Multimaps 使用map和multimap...
数据结构::关于STL中map,set,muliset,multimap要说的
海绵宝宝的欧尼~ 的博客
02-20 1194
前言： 1、对于关联式容器，在插入和删除的时候是不需要内存拷贝可内存移动的，所有的元素 都是用节点的方式进行存取，所以在这里插入和删除都是指针的移动，而不会发生内存 移动，因此在进行插入操作的时候是不会发生迭代器失效的问题的。 相对于vector来说，每一次删除和插入，指针都有可能失效，调用push_back在尾部插入也是如此。因为为了保证内部数据的连续存放，iterator指向的
Multiset用法总结
Code92007的博客
05-02 4418
心得 有的时候想用set但却总是不会用，multiset也是这样 有个题用了vector的erase结果复杂度是O(n)的 现在看来用multiset的话复杂度就是O(logn)的 苦于对红黑树一直没有了解，set就当黑框实现吧 思路来源 https://blog.csdn.net/sodacoco/article/details/84798621 用法 一些常用用法，和set比较...
multiset和multimap源码
Zyong139064359的博客
07-01 234
multiset的特性以及用法个set完全相同，唯一的差别就在于它允许键值重复。因此的 它的插入操作采用的是底层机制RB_tree的isnert_equal()而不是insert_unqiue(), 下面是multiset的源代码提要，只是列出了与set的不同之处 template <class Key,class Compare=less<Key,class Alloc=alloc&...
set 和 multiset 的区别
Anna的博客
04-25 1万+
multiset：多重集合，其实就是 set 集合的扩展版。 唯一的不同是 set 集合中一个值只能出现一次， 而多重集合中一个值可以出现多次。   粗略看了看MSDN，在STL中，multiset和set的成员函数声明也是基本一样的，一些需要注意的地方是： set::insert(key)的返回值是一个pair，其中pair中的bool成员表明了key被插入之前
set multiset unorderedset map multimap unorderedmap
最新发布
11-01
set和map的头文件是<set>和<map>，multiset和multimap的头文件是<set>和<map>，unordered_set和unordered_map的头文件是<unordered_set>和<unordered_map>，unordered_multiset和unordered_multimap的头文件是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值