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

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量757 收藏 21
点赞数 19
分类专栏： c++ C语言数据结构和算法 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzjm/article/details/137411751
版权

目录

红黑树的介绍

封装版本的红黑树

新增加的部分（迭代器）

map的模拟实现

set的模拟实现

红黑树的介绍

  • 大家可以去看我之前的博客模拟实现红黑树，里面详细的介绍了红黑树的主题逻辑，本文着重介绍迭代器和封装

封装版本的红黑树

  • 新版本红黑树的完整代码

#pragma once

namespace HQJ
{
 enum Color
 {
  RED,
  BLACK
 };

 //template<class K ,class V>这里不用data是为了封装做准备
 template<class T>//
 struct RBTreeNode
 {
  RBTreeNode<T>* _left;
  RBTreeNode<T>* _right;
  RBTreeNode<T>* _parent;
  T _data;
  Color _color;

  RBTreeNode(const T& data)
   :_left(nullptr)
   , _right(nullptr)
   , _parent(nullptr)
   , _data(data)
   , _color(RED)
  {}
 };

 template<class T>
 struct _iterator
 {
  typedef RBTreeNode<T> Node;
  typedef _iterator<T> self;
  Node* _node;

  _iterator(Node* node)
   :_node(node)
  {}

  self& operator++()
  {
   if (_node->_right != nullptr)
   {
    Node* cur = _node->_right;

    while (cur && cur->_left)
    {
     cur = cur->_left;
    }
    _node = cur;
   }
   else
   {
    Node* cur = _node;
    Node* parent = _node->_parent;

    while (parent && cur == parent->_right)
    {
     cur = parent;
     parent = cur->_parent;
    }
    _node = parent;
   }
   return *this;
  }
  
  bool operator!=(const self& node)
  {
   return _node != node._node;
  }

  bool operator==(const self& node)
  {
   return (*this != node);
  }
  T* operator->()
  {
   return &(_node->_data);
  }

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

 template<class K, class V, class keyOfT>
 class RBTree
 {
 public:
  typedef RBTreeNode<V> Node;
  typedef _iterator<V> iterator;
  iterator begin()
  {
   Node* cur = _root;
   while (cur && cur->_left)
   {
    cur = cur->_left;
   }

   return iterator(cur);
  }

  iterator end()
  {
   return iterator(nullptr);
  }
  bool Insert(const V& data)
  {
   if (_root == nullptr)
   {
    _root = new Node(data);
    _root->_color = BLACK;
    return true;
   }

   Node* parent = nullptr;
   Node* cur = _root;

   while (cur)
   {
    if (_kot(cur->_data) < _kot(data))
    {
     parent = cur;
     cur = cur->_right;
    }
    else if (_kot(cur->_data) > _kot(data))
    {
     parent = cur;
     cur = cur->_left;
    }
    else
    {
     return false;
    }
   }

   cur = new Node(data);
   cur->_color = RED;
   if (_kot(parent->_data) < _kot(data))
   {
    parent->_right = cur;
    cur->_parent = parent;
   }
   else
   {
    parent->_left = cur;
    cur->_parent = parent;
   }

   while (parent && parent->_color == RED)
   {
    Node* grandfather = parent->_parent;
    if (parent == grandfather->_left)
    {
     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->_left)
      {
       RotateR(grandfather);
       parent->_color = BLACK;
       grandfather->_color = RED;
      }
      else
      {
       RotateL(parent);
       RotateR(grandfather);
       cur->_color = BLACK;
       grandfather->_color = RED;
      }

      break;
     }
    }
    else
    {
     Node* uncle = grandfather->_left;
     if (uncle && uncle->_color == RED)
     {
      parent->_color = uncle->_color = BLACK;
      grandfather->_color = RED;

      cur = grandfather;
     }
     else
     {
      if (cur == parent->_right)
      {
       RotateL(grandfather);
       parent->_color = BLACK;
       grandfather->_color = RED;
      }
      else
      {
       RotateR(parent);
       RotateL(grandfather);
       cur->_color = BLACK;
       grandfather->_color = RED;
      }

      break;
     }
    }
   }

   _root->_color = BLACK;

   return true;
  }

  void RotateL(Node* parent)
  {
   Node* subR = parent->_right;
   Node* subRL = subR->_left;

   parent->_right = subRL;
   subR->_left = parent;

   Node* parentParent = parent->_parent;

   parent->_parent = subR;
   if (subRL)
    subRL->_parent = parent;

   if (_root == parent)
   {
    _root = subR;
    subR->_parent = nullptr;
   }
   else
   {
    if (parentParent->_left == parent)
    {
     parentParent->_left = subR;
    }
    else
    {
     parentParent->_right = subR;
    }

    subR->_parent = parentParent;
   }
  }

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

   parent->_left = subLR;
   if (subLR)
    subLR->_parent = parent;

   Node* parentParent = parent->_parent;

   subL->_right = parent;
   parent->_parent = subL;

   if (_root == parent)
   {
    _root = subL;
    subL->_parent = nullptr;
   }
   else
   {
    if (parentParent->_left == parent)
    {
     parentParent->_left = subL;
    }
    else
    {
     parentParent->_right = subL;
    }

    subL->_parent = parentParent;
   }
  }

  void InOrder()
  {
   _InOrder(_root);
   cout << endl;
  }

  void _InOrder(Node* root)
  {
   if (root == nullptr)
    return;

   _InOrder(root->_left);
   cout << root->_data.first << " ";
   _InOrder(root->_right);
  }

 private:
  // 根节点->当前节点这条路径的黑色节点的数量
  bool Check(Node* root, int blacknum, const int refVal)
  {
   if (root == nullptr)
   {
    //cout << balcknum << endl;
    if (blacknum != refVal)
    {
     cout << "存在黑色节点数量不相等的路径" << endl;
     return false;
    }

    return true;
   }

   if (root->_color == RED && root->_parent->_color == RED)
   {
    cout << "有连续的红色节点" << endl;

    return false;
   }

   if (root->_color == BLACK)
   {
    ++blacknum;
   }

   return Check(root->_left, blacknum, refVal)
    && Check(root->_right, blacknum, refVal);
  }
 public:
  bool IsBalance()
  {
   if (_root == nullptr)
    return true;

   if (_root->_color == RED)
    return false;

   //参考值
   int refVal = 0;
   Node* cur = _root;
   while (cur)
   {
    if (cur->_color == BLACK)
    {
     ++refVal;
    }

    cur = cur->_left;
   }

   int blacknum = 0;
   return Check(_root, blacknum, refVal);
  }

 private:
  Node* _root = nullptr;
  keyOfT _kot;
 };
}

新增加的部分（迭代器）

  • 成员变量

Node* _node;：指向当前迭代器所代表的红黑树节点的指针。

  • 构造函数

_iterator(Node* node) : _node(node) {}：接收一个指向红黑树节点的指针，并将其赋值给_node。

  • 前置递增运算符 operator++()

这个函数实现了迭代器的前置递增操作，即将迭代器移动到下一个节点。如果当前节点有右子树，则找到右子树中的最左侧节点作为下一个节点。如果当前节点没有右子树，则沿着父节点的链向上遍历，直到找到一个节点，该节点是其父节点的左子节点，或者遍历到根节点（即没有更多的父节点）。更新_node以指向新的节点。

  • 不等运算符 operator!=()

比较当前迭代器和另一个迭代器是否指向不同的节点。 如果两个迭代器的_node指针不同，则返回true，否则返回false。

  • 相等运算符 operator==()

比较当前迭代器和另一个迭代器是否指向相同的节点。实际上，这里的实现是通过调用operator!=()并返回其反值，可能不是最高效的实现方式，但逻辑上没有问题。

  • 解引用运算符 operator->()

允许通过迭代器直接访问节点的数据成员，类似于指针的解引用。 返回一个指向节点数据成员的指针。

  • 解引用运算符 operator*()

返回当前节点所存储的数据的引用。通过这个运算符，可以直接修改红黑树节点的数据。

template<class T>
 struct _iterator
 {
  typedef RBTreeNode<T> Node;
  typedef _iterator<T> self;
  Node* _node;

  _iterator(Node* node)
   :_node(node)
  {}

  self& operator++()
  {
   if (_node->_right != nullptr)
   {
    Node* cur = _node->_right;

    while (cur && cur->_left)
    {
     cur = cur->_left;
    }
    _node = cur;
   }
   else
   {
    Node* cur = _node;
    Node* parent = _node->_parent;

    while (parent && cur == parent->_right)
    {
     cur = parent;
     parent = cur->_parent;
    }
    _node = parent;
   }
   return *this;
  }
  
 
  bool operator!=(const self& node)
  {
   return _node != node._node;
  }

  bool operator==(const self& node)
  {
   return (*this != node);
  }
  T* operator->()
  {
   return &(_node->_data);
  }

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

map的模拟实现

  • 模板参数

myMap有两个模板参数：K和V，分别代表键（Key）的类型和值（Value）的类型。

  • 成员函数

  1. Insert(const pair<K, V>& data) 这个函数接受一个pair<K, V>类型的参数，并尝试将其插入到红黑树中。它直接调用红黑树的Insert函数来完成插入操作。

  2. 内部结构体 MapkeyOfT 这个结构体定义了一个函数对象（也称为仿函数），它接受一个pair<K, V>类型的参数，并返回其键（即pair的first成员）。这个函数对象被用作红黑树的键提取函数，以便红黑树能够正确地根据键来排序和查找节点。

  3. typedef别名 iterator 这里使用typedef为红黑树的迭代器类型定义了一个别名iterator。这个别名使得myMap的用户可以更方便地引用和使用迭代器。

  4. begin() 和 end() 这两个函数分别返回指向红黑树中第一个节点和尾后节点的迭代器。它们允许用户遍历myMap中的所有元素。

  • 私有成员

_tree是一个红黑树对象，它使用K作为键类型，pair<K, V>作为值类型，并使用MapkeyOfT作为键提取函数。

  • 模拟实现的全部代码

#pragma once
#include"RBTree.h"
namespace HQJ
{
 template<class K, class V>
 class myMap
 {
 public:
  
  bool Insert(const pair<K, V>& data)
  {
   return _tree.Insert(data);
  }

  struct MapkeyOfT
  {
   const K& operator()(const pair<K, V>& data)
   {
    return data.first;
   }
  };

  typedef typename RBTree<K, pair<K, V>, MapkeyOfT>::iterator iterator;

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

  iterator end()
  {
   return _tree.end();
  }
 private:
  RBTree<K, pair<K, V>, MapkeyOfT> _tree;
 };
}

set的模拟实现

  • 模板参数

mySet有一个模板参数K，代表集合中元素的类型。

  • 成员函数

  1. Insert(const K& data) 这个函数接受一个类型为K的参数，并尝试将其插入到红黑树中。它直接调用红黑树的Insert函数来完成插入操作。

  2. 内部结构体 SetkeyOfT 这个结构体定义了一个函数对象（也称为仿函数），它接受一个类型为K的参数，并返回该参数本身。这个函数对象被用作红黑树的键提取函数，以便红黑树能够正确地根据键来排序和查找节点。对于集合来说，键和值实际上是相同的，因此这个函数对象只是简单地返回了传入的参数。

  3. typedef别名 iterator 这里使用typedef为红黑树的迭代器类型定义了一个别名iterator。这个别名使得mySet的用户可以更方便地引用和使用迭代器。

  4. begin() 和 end() 这两个函数分别返回指向红黑树中第一个节点和尾后节点的迭代器。它们允许用户遍历mySet中的所有元素。

  • 私有成员

_tree是一个红黑树对象，它使用K作为键类型和值类型，并使用SetkeyOfT作为键提取函数。由于集合中键和值是相同的，因此这里使用了相同的类型K作为键和值。

  • 模拟实现的全部代码

#pragma once
#include"RBTree.h"

namespace HQJ
{
 template<class K>
 class mySet
 {
 public:
  
  bool Insert(const K& data)
  {
   return _tree.Insert(data);
  }

  struct SetkeyOfT
  {
   const K& operator()(const K& data)
   {
    return data;
   }
  };

  typedef typename RBTree<K, K, SetkeyOfT>::iterator iterator;

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

  iterator end()
  {
   return _tree.end();
  }
 private:
  RBTree<K, K, SetkeyOfT> _tree;
 };
}
正追军梦
关注
专栏目录
C++之模拟实现map和set
一只小卷毛的博客
04-11 721
基于之前的红黑树和map、set的相关知识，本节我们使用红黑树来模拟实现STL中的map和set。
C++之STLmap和set的模拟实现
小赵小赵福星高照的博客
03-21 1057
模拟实现map和set 文章目录模拟实现map和set源码中红黑树的结构模板参数中的仿函数红黑树的迭代器的模拟实现迭代器的基本结构红黑树的迭代器的整体代码map的模拟实现set的模拟实现 我们首先来看一下源码当中的set和map的结构： template <class Key,class Compare = less<Key>, class Alloc = alloc> class set { public: typedef Key key_type; typedef
c++ - 模拟实现set、map
2302_79539362的博客
08-02 746
c++ - 模拟实现set、map
C++红黑树模拟实现map和set
~
04-01 3940
C++红黑树模拟实现map和set零、前言一、红黑树及其节点的设计1、树节点的设计2、红黑树的设计3、取值仿函数的使用二、红黑树的迭代器1、begin()与end()2、operator++()与operator--()3、正反迭代器的实现三、map和set的实现1、红黑树的实现2、map的封装3、set的封装 零、前言 本章是继红黑树的介绍和实现后，讲解使用红黑树来封装实现map和set 一、红黑树及其节点的设计 对于底层都是红黑树的map和set来说，他们之间存在的最大的区别就是：对于set是K模
C++ unordered_map与unordered_set的模拟实现
wxk2227814847的博客
07-27 1025
通过本文，我们详细介绍了如何使用C++实现unordered_map和unordered_set，并展示了其底层哈希表的实现。通过这些示例代码，读者可以深入理解哈希表的工作原理及其在C++中的应用。在实际开发中，灵活运用哈希表能够大幅提升程序的性能和效率。希望本文能够帮助读者掌握哈希表及其相关容器的实现与应用。
【C++】map 和 set
在平淡的日子里寻找存在的价值
03-24 1135
map/multimap 的使用以及 set/multiset 的使用
C++ Map Set的模拟实现
m0_52420323的博客
07-23 1151
摘要：C++，数据结构，Map，Set
C++STL之map、set的使用和模拟实现
溟洵的博客
01-29 1497
本章主要讲了map、set是如何使用的，以及map、set如何底层实现相较于前面的章节本章更加考验你的逻辑能力来进行封装，还能帮助对大体框架的有更加好的了解。
C++ map和set模拟实现
努力学习C/C++
04-20 886
前面我们实现了红黑树，本篇就讲map和set的底层是怎么用红黑树来进行封装的！！！我们要模拟实现map和set需要改造之前的红黑树，因为set只有一个K，而我们的红黑树模板参数是2个一个T和一个V。
【C++】map和set的模拟实现
EWIAW_ilove的博客
07-09 831
在本篇博客中，作者将会带领你C++STL库中的，其中我只实现一些比较重要的成员函数，在进行之前，你需要先懂得，因为map和set的。
map和set的模拟实现
06-06
这将帮助我们更好地理解和实现红黑树，从而有效地模拟出Map和Set。 总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在...
【C++ STL】模拟实现 map 和 set（对一颗红黑树进行封装）
codewinter的博客
06-25 721
阅读STL源码就可以发现，其实 set 和 map 自己没有实现啥东西，整体就是对红黑树进行了一个封装，set 和 map 的 insert / erase 接口底层就是调用红黑树的 insert / erase 接口，并且 set 和 map 的迭代器也都是取的红黑树里面的迭代器那 set 和 map 的核心区别在哪里呢？set 底层封装了一颗红黑树，是 KV 结构，值得注意的是 key_type 和 value_type 都是 key，说明传了两个 key 给红黑树。 map 底层封装了一颗红黑树，是
模拟实现unordered_map和unordered_set超详解（C++）
m0_67430750的博客
05-19 2234
模拟实现unordered_map、unordered_set超详解，包括哈希表以及unordered_map、unordered_set完整代码，迭代器封装、功能测试等。
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 854
C++实现哈希表封装unordered_map unordered_set
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 261
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 578
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 559
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 451
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 701
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
unordered_map和unordered_set的模拟实
10-07
unordered和unordered_set是C++标准库中的关联式容器。它们的模拟实现基于哈希表的数据结构。哈希表通过将关键字映射到表中的一个位置来进行访问，从而实现快速的查找和插入操作。 unordered_map是存储键值对的关联式容器，它通过key快速索引到与其对应的value。在unordered_map中，键值通常用于唯一地标识元素，而映射值是一个对象，与该键相关联。unordered_map不对键值对按任何特定的顺序排序，而是使用哈希值将具有相同哈希值的键值对放在同一个桶中。unordered_map容器通过key访问单个元素的效率比map高，但在遍历元素子集时的迭代效率较低。 unordered_set是存储唯一值的关联式容器，它只存储值，而不存储键。unordered_set使用哈希表来存储值，并根据哈希值将具有相同哈希值的值放在同一个桶中。unordered_set容器通过值来确定元素是否存在，并且插入和查找操作的平均时间复杂度为O(1)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值