【C++】map、set模拟实现

文章目录

  • 一. 整体框架梳理
  • 二. 节点类
  • 三. 迭代器
    • 1. 迭代器的基本框架
    • 2. operator++ 和 operator- -
    • 3. operator* 和 operator->
    • 4. operator== 和 operator!=
    • 5. 迭代器完整代码
  • 四. 红黑树
    • 1. 红黑树基本框架
    • 2. begin()和end()
    • 3. empty()和size()
    • 4. Insert 和 Find
    • 5. 红黑树完整代码
  • 五. map和set
    • 1. map、set的基本框架
    • 2. map、set和红黑树之间的关系
    • 3. map、set完整代码

一. 整体框架梳理

【C++】map、set模拟实现_第1张图片
所谓低层被高层封装就是低层类要作为高层类的成员变量。比如红黑树和迭代器,它们的成员变量都是一个树的节点;而map和set类的成员变量是同一颗红黑树,它们的接口都是通过直接或间接调用红黑树的接口实现的。


二. 节点类

节点类是一个类模板,模板参数ValueType就是节点存储的数据的类型。成员变量包括指向父亲、左右孩子的指针,节点的颜色和节点存储的数据。成员函数就只有一个构造函数,传入一个ValueType的数据来构造一个节点。

// 枚举定义颜色
enum COLOR
{
  RED,
  BLACK
};

// 节点的定义
template<class ValueType>
struct RBTreeNode
{
  // 构造函数,颜色默认给为红色
  RBTreeNode(const ValueType& data)
    :_color(RED)
    ,_data(data)
    ,_parent(nullptr)
    ,_left(nullptr)
    ,_right(nullptr)
  {}

  COLOR _color;
  ValueType _data;
  RBTreeNode<ValueType>* _parent;                                                                                     
  RBTreeNode<ValueType>* _left;
  RBTreeNode<ValueType>* _right;
};

三. 迭代器

1. 迭代器的基本框架

底层封装一个树节点的指针_node,所以构造函数是传入一个树节点的指针让_node指向它。

template<class ValueType, class Ref, class Ptr>
class RBTreeItetator
{
    typedef RBTreeNode<ValueType> Node;
    typedef RBTreeItetator<ValueType, Ref, Ptr> self;
  public:
    RBTreeItetator(Node* node)
      :_node(node)
    {}
  private:
    Node* _node;
};

为了实现const迭代器,模板参数除了节点的数据类型外还引入了数据类型的引用(Reference)和数据类型的指针(Pointer)。在迭代器重载解引用和箭头运算符时,不论外面传入的模板参数是什么,都返回Ref和Ptr,可以看到这两个模板参数的引入使得代码更加灵活,这是模板优点的体现,也是泛型编程思想的一个体现。
【C++】map、set模拟实现_第2张图片

2. operator++ 和 operator- -

先看自增,我们想要这个迭代器指向下一个节点,根据中序遍历的规则可以得到下面结论:

  • 如果右不为空,中序的下一个就是右子树的最左节点
    【C++】map、set模拟实现_第3张图片

  • 如果右为空,表示当前节点所在的子树已经遍历完成,下一个节点为沿着路径往上孩子是它的左的那个祖先
    【C++】map、set模拟实现_第4张图片

自减操作的话,就是找前一个节点,和自增的思路相反,不再赘述。它们的实现如下:

// 前置自增操作
self& operator++()    
{    
  if(_node->_right)    
  {    
    Node* subRL=_node->_right;    
    while(subRL->_left)                                                                                                     
    {    
      subRL=subRL->_left;    
    }    
    _node=subRL;    
  }    
  else     
  {    
    Node* cur=_node;    
    Node* parent=cur->_parent;    
    while(parent && cur == parent->_right)    
    {    
      cur=parent;    
      parent=parent->_parent;    
    }    
    _node=parent;    
  }    
  return *this;    
}   

// 后置自减操作
self& operator--()
{
  if(_node->_left)
  {
    Node* subLR=_node->_left;
    while(subLR->_right)
    {
      subLR=subLR->_right;
    }
    _node=subLR;
  }
  else 
  {
    Node* cur=_node;
    Node* parent=cur->_parent;
    while(parent && cur==parent->_left)
    {
      cur=parent;
      parent=parent->_parent;
    }                                                                                                                       
    _node=parent;
  }
  return *this;
}

3. operator* 和 operator->

解引用就是返回节点中存储的数据的引用,箭头返回节点中存储数据的指针。

Ref operator*()
{
  return _node->_data;
}

Ptr operator->()
{
  return &_node->_data;
}

编译器对箭头操作符的特殊处理

所谓迭代器就是模拟像指针一样的东西,我们希望通过解引用迭代器来直接获取所存储的数据对象本身,我们上面的实现确实做到了;我们也希望通过箭头操作符操作迭代器直接访问存储数据内的成员,在使用箭头操作符时会遇到一些问题。
【C++】map、set模拟实现_第5张图片

4. operator== 和 operator!=

比较两个迭代器是否相等,就是比较底层的成员变量即节点对象是否相等。

bool operator==(const self& it)
{
  return _node == it._node;
}

bool operator!=(const self& it)
{
  return _node != it._node;
}

5. 迭代器完整代码

// 迭代器    
template<class ValueType, class Ref, class Ptr>    
class RBTreeItetator    
{    
    typedef RBTreeNode<ValueType> Node;    
    typedef RBTreeItetator<ValueType, Ref, Ptr> self;    
      
  public:                                                                                                                       
    RBTreeItetator(Node* node)    
      :_node(node)    
    {}    
        
    self& operator++()    
    {    
      if(_node->_right)    
      {    
        Node* subRL=_node->_right;    
        while(subRL->_left)    
        {    
          subRL=subRL->_left;    
        }    
        _node=subRL;    
      }    
      else     
      {    
        Node* cur=_node;
        Node* parent=cur->_parent;
        while(parent && cur == parent->_right)
        {
          cur=parent;
          parent=parent->_parent;
        }
        _node=parent;
      }
      return *this;
    }

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

    Ref operator*()
    {
      return _node->_data;
    }

    Ptr operator->()                                                                                                            
    {
      return &_node->_data;
    }

    bool operator==(const self& it)
    {
      return _node == it._node;
    }

    bool operator!=(const self& it)
    {
      return _node != it._node;
    }

  private:
    Node* _node;                                                                                                                
};

四. 红黑树

1. 红黑树基本框架

成员变量有两个:记录该树节点个数的_size和该树的根_root。

// 树的定义                                                                                                                     
template<class Key, class ValueType, class KeyOfValue>    
class RBTree     
{    
    typedef RBTreeNode<ValueType> Node;    
  public:    
    typedef RBTreeItetator<ValueType, ValueType&, ValueType*> Iterator;    
    typedef RBTreeItetator<ValueType, const ValueType&, const ValueType*> const_Iterator;    
    
    RBTree()    
      :_size(0)    
      ,_root(nullptr)    
    {} 
  private:
    size_t _size;
    Node* _root;
}; 

关于typedef的几点说明

我们对节点类重定义为Node,后面会经常用到为了方便写才重定义的,权限为private因为我们只在类内部使用。另外我们还对迭代器进行了重定义,包括const迭代器和非const迭代器,为了可读性和写起来便捷才重定义,权限为public因为有从外部读取的需要:
【C++】map、set模拟实现_第6张图片

如何用一棵红黑树同时实现map和set?

在这里插入图片描述
通过对模板参数的巧妙设计可以实现。第一个模板参数Key是节点排序和比较的唯一标识,如果是set的话key就是它自己本身存储的数据,如果是map的话key就是键值对的第一个值。第二个模板参数是map和set存储的数据,map的话是pair键值对,set的话是key。
【C++】map、set模拟实现_第7张图片

关于Insert中插入数据的比较方式

【C++】map、set模拟实现_第8张图片
此时红黑树的第三个参数就起作用了,它是一个仿函数,map、set各自实现一个并传递给一同颗红黑树。KeyOfValue,顾名思义就是获取ValueType中的Key,即存储数据作为比较的唯一表示。虽然map和set的对KeyOfValue实现不同,但可以完美地匹配它们自己的ValuType,当插入时统一调用这个仿函数来获取Key进行比较,这又是一种泛型编程的体现。
【C++】map、set模拟实现_第9张图片

第一个模板参数的作用?

第二个模板参数和第三个模板参数我们都在Insert()中实用到了,传入的第一个模板参数Key有什么用呢?在Find()中就会用到第一个模板参数,我们调用Find()时传入的实参类型就是Key。
在这里插入图片描述

2. begin()和end()

红黑树的成员变量是整棵树的根节点,begin()要返回第一个节点的迭代器,根据中序遍历的规则往前找就是去找左子树的最左节点;end()的话就返回一个空的迭代器。最后普通对象返回普通迭代器,const对象返回const迭代器,至于对象是普通的还是const的由在我们在创建map或set对象时它们的属性来决定,因为map和set底层封装红黑树,它们的对象如果是const的话,封装的红黑树也是const的,对应返回const迭代器。

Iterator Begin()    
{    
  Node* subL=_root;    
  while(subL && subL->_left)    
  {    
    subL=subL->_left;    
  }    
  return Iterator(subL);    
}    

const_Iterator Begin() const    
{    
  Node* subL=_root;    
  while(subL && subL->_left)    
  {    
    subL=subL->_left;    
  }    
  return const_Iterator(subL);   
  }

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

const_Iterator End() const
{
  return const_Iterator(nullptr);
}

3. empty()和size()

红黑树除了根节点外还有一个记录当前节点数的成员变量_size。
empty()的话就是判断_size是否等于0。
size()的话直接返回_size的值就行。

size_t Size() const 
{
  return _size;
}

bool Empty() const 
{
  return _size == 0;
}

4. Insert 和 Find

这些都是红黑树的基本操作,没有什么太多特别的和与其他类相关联的东西,相关代码放到下面的完整代码里。一定要说的话就是他们的返回值:

  • Insert返回一个pair键值对,它的first为节点的迭代器,second为布尔值。如果插入成功first为新插入节点的迭代器,second为true;如果插入失败(要插入的Key已经存在),此时pair的first为那个已经存在的节点的迭代器,second为false。
  • Find返回一个迭代器,如果找到了返回该节点的迭代器,找不到返回空迭代器,即end()

5. 红黑树完整代码

// 红黑树的定义
template<class Key, class ValueType, class KeyOfValue>
class RBTree 
{
    typedef RBTreeNode<ValueType> Node;
  public:
    typedef RBTreeItetator<ValueType, ValueType&, ValueType*> Iterator;
    typedef RBTreeItetator<ValueType, const ValueType&, const ValueType*> const_Iterator;

    RBTree()
      :_size(0)
      ,_root(nullptr)
    {}

    Iterator Begin()
    {
      Node* subL=_root;
      while(subL && subL->_left)
      {
        subL=subL->_left;
      }
      return Iterator(subL);
    }

    const_Iterator Begin() const
    {
      Node* subL=_root;
      while(subL && subL->_left)
      {
        subL=subL->_left;
      }
      return const_Iterator(subL);
    }

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

    const_Iterator End() const
    {
      return const_Iterator(nullptr);
    }

    size_t Size() const 
    {
      return _size;
    }

    bool Empty() const 
    {
      return _size == 0;
    }

    // 插入一个节点
    pair<Iterator, bool> Insert(const ValueType& data)
    {
      // 第一步:按搜索树规则插入一个节点
      // 1、空树的话插入节点作为根节点
      // 2、不空的话,按搜索树规则找到插入的位置,然后插入
      if(!_root)
      {
        _root=new Node(data);
        _root->_color=BLACK;
        ++_size;
        return make_pair(Iterator(_root), true);
      }
      // 寻找插入的位置
      KeyOfValue kov;
      Node* parent=nullptr;
      Node* cur=_root;
      while(cur)
      {
        parent=cur;
        if(kov(cur->_data) == kov(data))
        {
          return make_pair(Iterator(cur), false);
        }
        else if(kov(cur->_data) < kov(data))
        {
          cur=cur->_right;
        }
        else if(kov(cur->_data) > kov(data))
        {
          cur=cur->_left;
        }
      }
      // 找到后插入
      Node* newNode=new Node(data);
      newNode->_parent=parent;
      if(kov(parent->_data) > kov(data))
      {
        parent->_left=newNode;
      }
      else if(kov(parent->_data) < kov(data)) 
      {
        parent->_right=newNode;
      }
      // 第二步:调整节点的颜色
      // 1、如果父亲颜色为黑就不用调整
      // 2、如果父亲节点颜色为红,调整方式由叔叔决定
      //    a、叔叔存在且为红 --> 把叔叔和父亲的颜色调整为黑,爷爷颜色调整为红,然后继续往上调整
      //    b、叔叔不存在或存在且为黑 --> 看爷爷、父亲、和cur的相对位置来决定用什么旋转,旋转后调整父亲和爷爷的颜色
      cur=newNode;
      while(parent &&  parent->_color == RED)
      {
        // 既然进来了这个循环内部,说明父亲一定是红色,那么一定有爷爷且爷爷颜色为黑
        Node* grandfather = parent->_parent;
        // 确定叔叔的位置
        if(grandfather->_left == parent)
        {
          Node* uncle=grandfather->_right;
          if(uncle && uncle->_color == RED)// 叔叔存在且为红
          {
            parent->_color=uncle->_color=BLACK;
            grandfather->_color=RED;
            cur=grandfather;
            parent=cur->_parent;
          }
          else // 叔叔不存在或者存在且为黑
          {
            if(cur == parent->_right)
            {
              RotateL(parent);
              std::swap(parent,cur);
            }
            RotateR(grandfather);
            parent->_color=BLACK;
            grandfather->_color=RED;
            break;
          }
        }
        else if(grandfather->_right == parent)
        {
          Node* uncle=grandfather->_left;
          if(uncle && uncle->_color==RED)// 叔叔存在且为红
          {
            uncle->_color=parent->_color=BLACK;
            grandfather->_color=RED;
            cur=grandfather;
            parent=cur->_parent;
          }
          else // 叔叔不存在或存在且为黑
          {
            if(cur == parent->_left)
            {
              RotateR(parent);
              std::swap(parent,cur);
            }
            RotateL(grandfather);
            parent->_color=BLACK;
            grandfather->_color=RED;
            break;
          }
        }
      }
      _root->_color=BLACK;
      ++_size;
      return make_pair(Iterator(newNode), true); 
    }

    KeyOfValue kov;
   Iterator Find(const Key& k)
   {
     Node* cur=_root;
     while(cur)
     {
       if(kov(cur->_data) > k)
       {
         cur=cur->_left;
       }
       else if(kov(cur->_data) < k)
       {
         cur=cur->_right;
       }
       else 
       {
         return Iterator(cur);
       }
     }
     return Iterator(nullptr);
   }

   const_Iterator Find(const Key& k) const
   {
     Node* cur=_root;
     while(cur)
     {
       if(kov(cur->_data) > k)
       {
         cur=cur->_left;
       }
       else if(kov(cur->_data) < k)
       {
         cur=cur->_right;
       }
       else 
       {
         return const_Iterator(cur);
       }
     }
     return const_Iterator(nullptr);
    }

 private:
    // 左单旋
    void RotateL(Node* parent)
    {
      Node* subR=parent->_right;
      Node* subRL=subR->_left;
      parent->_right=subRL;
      if(subRL != nullptr)
      {
        subRL->_parent=parent;
      }
      subR->_left=parent;
      Node* pparent=parent->_parent;
      parent->_parent=subR;
      if(pparent == nullptr)
      {
        _root=subR;
        subR->_parent=nullptr;
      }
      else 
      {
        subR->_parent=pparent;
        if(pparent->_left == parent)
        {
          pparent->_left=subR;
        }
        else if(pparent->_right == parent)
        {
          pparent->_right=subR;
        }
      }
    }

    // 右单旋
    void RotateR(Node* parent)
    {
      Node* subL=parent->_left;
      Node* subLR=subL->_right;

      parent->_left=subLR;
      if(subLR != nullptr)
      {
        subLR->_parent=parent;
      }
      subL->_right=parent;
      Node* pparent=parent->_parent;
      parent->_parent=subL;
      if(pparent == nullptr)
      {
        _root=subL;
        subL->_parent=nullptr;
      }
      else 
      {
        subL->_parent=pparent;
        if(pparent->_left == parent)
        {
          pparent->_left=subL;
        }
        else if(pparent->_right == parent) 
        {
          pparent->_right=subL;
        }
      }
    }

    size_t _size;
    Node* _root;
};

五. map和set

1. map、set的基本框架

它们两个的成员变量都是一颗红黑树,并且都自己实现仿函数KeyOfValue。不同点在于模板参数不同,map因为存储键值对所以有两个模板参数;set只有一个模板参数Key。

// map的基本框架
template<class K, class V>    
class MyMap    
{    
    typedef pair<K, V> ValueType;    
    
    struct KeyOfValue     
    {    
      const K& operator()(const ValueType& v)    
      {    
        return v.first;    
      }    
    }    
  private:    
    RBTree<K, ValueType, KeyOfValue> _t;    
};  

// set的基本框架
template<class K>                                                                                                             
class MySet          
{                    
    typedef K ValueType;      
                          
    struct KeyOfValue      
    {                  
      const K& operator()(const ValueType& k)      
      {                                        
        return k;      
      }            
    };    
  private:             
    RBTree<K, ValueType, KeyOfValue> _t;    
 };                                                                              

2. map、set和红黑树之间的关系

map、set都有的接口包括begin()、end()、empty()、size()、Find、Insert等等,看到上面这些接口有没有觉得很熟悉?没错,这些都是上面红黑树已经实现了的接口,map和set因为底层是红黑树所以可以直接调用这些接口,至于有多直接,从它们两个的完整代码里可见一斑。

map和set相当于红黑树的的一件衣服,对内把红黑树装饰和保护了起来,对外使得使用者操作红黑树更加方便、容易理解。

3. map、set完整代码

map

这里要注意一下 [ ] 这个操作符的重载,这是map独有的,底层通过封装Insert实现。方括号内我们传入Key,如果存在的话返回Value的引用;如果不存在,则新插入这个节点,它的Value为对应类型的一个匿名对象,调用其默认构造函数。即该操作符的功能是无论如何都返回给你对应key的value。
【C++】map、set模拟实现_第10张图片

template<class K, class V>
class MyMap
{
    typedef pair<K, V> ValueType;

    struct KeyOfValue 
    {
      const K& operator()(const ValueType& v)
      {
        return v.first;
      }
    };

  public:
    typedef typename RBTree<K, ValueType, KeyOfValue>::Iterator Iterator;
    typedef typename RBTree<K, ValueType, KeyOfValue>::const_Iterator const_Iterator;
    pair<Iterator, bool> Insert(const ValueType& v)
    {
      return _t.Insert(v);
    }

    Iterator Begin()
    {
      return _t.Begin();
    }

    const_Iterator Begin() const
    {
      return _t.Begin();
    }

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

    const_Iterator End() const
    {
      return  _t.End();
    }

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

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

    Iterator Find(const K& k)
    {
      return _t.Find(k); 
    }

    const_Iterator Find(const K& k) const
    {
      return _t.Find(k); 
    }

    V& operator[](const K& k)
    {
      pair<Iterator, bool> ret=_t.Insert(make_pair(k, V()));
      return ret.first->second; 
    }

  private:
    RBTree<K, ValueType, KeyOfValue> _t;
};

set

template<class K>
class MySet
{
  typedef K ValueType;
  struct KeyOfValue
  {
    const K& operator()(const ValueType& k)
    {
      return k;
    }
  };

  public:
    typedef typename RBTree<K, ValueType, KeyOfValue>::Iterator Iterator;
    typedef typename RBTree<K, ValueType, KeyOfValue>::const_Iterator const_Iterator;

    pair<Iterator, bool> Insert(const ValueType& k)
    {
       return _t.Insert(k);
    }

    Iterator Begin()
    {
      return _t.Begin();
    }

    const_Iterator Begin() const
    {
      return _t.Begin();
    }

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

    const_Iterator End() const 
    {
      return _t.End();
    }

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

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

    Iterator Find(const K& k)
    {
      return _t.Find(k);
    }

    const_Iterator Find(const K& k) const
    {
      return _t.Find(k);
    }

  private:
    RBTree<K, ValueType, KeyOfValue> _t;
};

你可能感兴趣的:(C++,c++,map,数据结构)