【C++】17.map和set的模拟实现

最新推荐文章于 2024-06-24 20:47:34 发布
最新推荐文章于 2024-06-24 20:47:34 发布
阅读量397 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szh0331/article/details/130154322
版权

1.红黑树中的迭代器

operator++是关键 迭代需要走中序 如何走中序?

_node从左子树的最左结点开始遍历走中序

分两类情况:

  1. 如果右树不为空 那么中序的下一个就是右子树的最左结点

  2. 如果右树为空 那么表示_node所在的子树已经完成 在一个结点的祖先去找

    沿着路径往上孩子是它的左的那个祖先

//迭代器
template<class T, class Ref, class Ptr>
struct __TreeIterator
{
    typedef RBTreeNode<T> Node;
    typedef __TreeIterator<T, Ref, Ptr> Self;
    Node* _node;

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

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

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

    //++如何走?
    Self& operator++()
    {
        //STL给了头结点 左孩子指向最左结点 右孩子指向最右结点
        //_node为左子树的最左结点 从这开始
        //1.如果右不为空 中序的下一个就是右子树的最左结点
        //2.如果右为空 表示_node所在的子树已经放完成 在一个结点的祖先去找
        //沿着路径往上孩子是它的左的那个祖先
        //右树不为空
        if (_node->_right)
        {
            //中序的下一个就是右子树的最左结点
            Node* subLeft = _node->_right;
            while (subLeft->_left)
            {
                subLeft = subLeft->_left;
            }

            _node = subLeft;
        }
        //右树为空
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            //右孩子就停下来 去找最左结点
            while (parent && cur == parent->_right)
            {
                cur = cur->_parent;
                parent = parent->_parent;
            }

            _node = parent;
        }
        return *this;
    }

    Self& operator--()
    {
        //与++相反
        //右根左
        //1.如果左不为空 就访问左树的最右结点
        //2.如果左为空 找为右孩子的那个祖先
        return *this;
    }

    bool operator!=(const Self& s)
    {
        return _node != s._node;
    }
};

整颗红黑树

#pragma once
#include <iostream>
using namespace std;

enum Colour
{
    BLACK,
    RED,
};

template<class T>
struct RBTreeNode
{
    RBTreeNode<T>* _left;
    RBTreeNode<T>* _right;
    RBTreeNode<T>* _parent;
    
    T _data;

    Colour _col;

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

//迭代器
template<class T, class Ref, class Ptr>
struct __TreeIterator
{
    typedef RBTreeNode<T> Node;
    typedef __TreeIterator<T, Ref, Ptr> Self;
    Node* _node;

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

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

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

    //++如何走?
    Self& operator++()
    {
        //STL给了头结点 左孩子指向最左结点 右孩子指向最右结点
        //_node为左子树的最左结点 从这开始
        //1.如果右不为空 中序的下一个就是右子树的最左结点
        //2.如果右为空 表示_node所在的子树已经放完成 在一个结点的祖先去找
        //沿着路径往上孩子是它的左的那个祖先
        //右树不为空
        if (_node->_right)
        {
            //中序的下一个就是右子树的最左结点
            Node* subLeft = _node->_right;
            while (subLeft->_left)
            {
                subLeft = subLeft->_left;
            }

            _node = subLeft;
        }
        //右树为空
        else
        {
            Node* cur = _node;
            Node* parent = cur->_parent;
            //右孩子就停下来 去找最左结点
            while (parent && cur == parent->_right)
            {
                cur = cur->_parent;
                parent = parent->_parent;
            }

            _node = parent;
        }
        return *this;
    }

    Self& operator--()
    {
        //与++相反
        //右根左
        //1.如果左不为空 就访问左树的最右结点
        //2.如果左为空 找为右孩子的那个祖先
        return *this;
    }

    bool operator!=(const Self& s)
    {
        return _node != s._node;
    }
};

template<class K, class T, class KOfT>
class RBTree
{
    typedef RBTreeNode<T> Node;
public:
    typedef __TreeIterator<T, T&, T*> iterator;
    typedef __TreeIterator<T, const T&, const T*> const_iterator;

    iterator begin()
    {
        Node* cur = _root;
        while (cur && cur->_left)
        {
            cur = cur->_left;
        }

        return iterator(cur);
    }

    iterator end()
    {
        return iterator(nullptr);
    }

    //插入
    pair<iterator, bool> Insert(const T& data)
    {
        if (_root == nullptr)
        {
            _root = new Node(data);
            _root->_col = BLACK; //根结点必须是黑色
            return make_pair(iterator(_root), true); //插入成功
        }

        KOfT koft;
        //二叉搜索树
        Node* cur = _root;
        Node* parent = nullptr;
        while (cur)
        {
            if (koft(data) < koft(cur->_data))
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (koft(data) > koft(cur->_data))
            {
                parent = cur;
                cur = cur->_right;
            }
            else
            {
                return make_pair(iterator(cur), false);
            }
        }

        //将结点插入
        cur = new Node(data);
        Node* newnode = cur;
        if (koft(cur->_data) < koft(parent->_data))
        {
            parent->_left = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_right = cur;
            cur->_parent = parent;
        }

        //------------------------
        //新增结点红的 or 黑的
        //破坏b还是c 破坏b较轻 
        //1.只影响一条路径
        //2.还不一定破坏规则
        //所以选红的
        cur->_col = RED;
        //-------------------------------
        //调色
        //第一种情况:cur为红 p为红 g为黑 只要u存在且为红-> p和u变黑 g变红 继续往上处理 如果到根 根要变回黑 
        //ps:需要注意的是 这里只关注颜色 而p g u几个结点在左边或者右边是一样的
        //最后就是为了防止连续的红和保持每条支路黑的结点数量一样
        //-------------------------------------
        //第二种情况:cur为红 p为红 g为黑 u不存在/u为黑 直线
        //1.如果u不存在 那么cur就是新增结点
        //旋转+变色
        //旋转:左单旋 or 右单旋
        //变色:g变红 p变黑
        //--------------------------------------- 
        //2.如果u存在且为黑 那么cur一定不是新增
        //你要保证每条路黑色结点数量一样->cur一定是黑的
        //cur变红的话就是第一种情况
        //---------------------------------------
        //第三种情况:cur为红 p为红 g为黑 u不存在/u为黑 折线
        //旋转:左右双旋 or 右左双旋
        //变色:g变红 cur变黑
        //-------------------------------------

        //parent为红
        while (parent && parent->_col == RED)
        {
            Node* grandfather = parent->_parent;
            if (parent == grandfather->_left)
            {
                Node* uncle = grandfather->_right;
                if (uncle && uncle->_col == RED) //情况1：uncle存在且为红
                {
                    //颜色调整
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;

                    //继续往上处理
                    cur = grandfather;
                    parent = cur->_parent;
                }
                else //情况2+情况3：uncle不存在 + uncle存在且为黑
                {
                    if (cur == parent->_left)
                    {
                        RotateR(grandfather);

                        grandfather->_col = RED;
                        parent->_col = BLACK;
                    }
                    else //cur == parent->_right
                    {
                        RotateLR(grandfather);

                        grandfather->_col = RED;
                        cur->_col = BLACK;
                    }
                    break; //子树旋转后，该子树的根变成了黑色，无需继续往上进行处理
                }
            }
            else //parent是grandfather的右孩子
            {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_col == RED) //情况1：uncle存在且为红
                {
                    //颜色调整
                    uncle->_col = parent->_col = BLACK;
                    grandfather->_col = RED;

                    //继续往上处理
                    cur = grandfather;
                    parent = cur->_parent;
                }
                else //情况2+情况3：uncle不存在 + uncle存在且为黑
                {
                    if (cur == parent->_left)
                    {
                        RotateRL(grandfather);

                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    else //cur == parent->_right
                    {
                        RotateL(grandfather);

                        grandfather->_col = RED;
                        parent->_col = BLACK;
                    }
                    break; //子树旋转后，该子树的根变成了黑色，无需继续往上进行处理
                }
            }
        }
        _root->_col = BLACK; //根结点的颜色为黑色（可能被情况一变成了红色，需要变回黑色）
        
        return make_pair(iterator(newnode), true);
    }

    //左单旋
    void RotateL(Node* parent)
    {
        //需要处理subR的parent left
        //需要处理subRL的parent
        //需要处理parent的right parent
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        Node* parentParent = parent->_parent;

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

        subR->_left = parent;
        parent->_parent = subR;

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

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

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

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

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

    //左右双旋
    void RotateLR(Node* parent)
    {
        RotateL(parent->_left);
        RotateR(parent);
    }

    //右左双旋
    void RotateRL(Node* parent)
    {
        RotateR(parent->_right);
        RotateL(parent);
    }

    //中序遍历
    void Inorder()
    {
        _Inorder(_root);
    }


    void _Inorder(Node* root)
    {
        if (root == nullptr)
            return;
        _Inorder(root->_left);
        //cout << root->_kv.first << ":" << root->_kv.second << endl;
        _Inorder(root->_right);
    }

    //判断是否为红黑树
    bool ISRBTree()
    {
        if (_root == nullptr) //空树是红黑树
        {
            return true;
        }
        if (_root->_col == RED)
        {
            cout << "error：根结点为红色" << endl;
            return false;
        }

        //找最左路径作为黑色结点数目的参考值
        Node* cur = _root;
        int BlackCount = 0;
        while (cur)
        {
            if (cur->_col == BLACK)
                BlackCount++;
            cur = cur->_left;
        }

        int count = 0;
        return _ISRBTree(_root, count, BlackCount);
    }

    bool _ISRBTree(Node* root, int count, int BlackCount)
    {
        if (root == nullptr) //该路径已经走完了
        {
            if (count != BlackCount)
            {
                cout << "error：黑色结点的数目不相等" << endl;
                return false;
            }
            return true;
        }

        if (root->_col == RED && root->_parent->_col == RED)
        {
            cout << "error：存在连续的红色结点" << endl;
            return false;
        }
        if (root->_col == BLACK)
        {
            count++;
        }
        return _ISRBTree(root->_left, count, BlackCount) && _ISRBTree(root->_right, count, BlackCount);
    }

    //查找函数
    iterator Find(const K& key)
    {
        KOfT koft;
        Node* cur = _root;
        while (cur)
        {
            if (koft(data) < koft(cur->_data))
            {
                cur = cur->_left;
            }
            else if (koft(data) > koft(cur->_data))
            {
                cur = cur->_right;
            }
            else
            {
                return iterator(cur);
            }
        }

        return iterator(nullptr);
    }

private:
    Node* _root = nullptr;
};

2.MySet和MyMap

如何使用一颗红黑树实现map和set

利用模板 KOfT 传K的时候返回K 传pair<K,V>的时候也返回K

这样就可以同时满足set和map

MySet

#pragma once

#include "RBTree1.h"

namespace szh
{
    template<class K>
    class set
    {
        struct SetKeyOfT
        {
            const K& operator()(const K& k)
            {
                return k;
            }
        };
    public:
        //编译器会找不到 没有实例化 加上typename 告诉编译器这里是类型名称
        typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;

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

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

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

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

    void test_set()
    {
        set<int> s;
        s.Insert(3);
        s.Insert(4);
        s.Insert(1);
        s.Insert(2);
        s.Insert(5);
        
        set<int>::iterator it = s.begin();
        while (it != s.end())
        {
            cout << *it << " ";
            ++it;
        }
        cout << endl;

        for (auto k: s)
        {
            cout << k << " ";
        }
        cout << endl;
    }
};

MyMap

#pragma once

#include "RBTree1.h"

namespace szh
{
    template<class K, class V>
    class map
    {
        struct MapKeyOfT
        {
            const K& operator()(const pair<K, V>& kv)
            {
                return kv.first;
            }
        };
    public:
        //编译器会找不到 没有实例化 加上typename 告诉编译器这里是类型名称
        typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;

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

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

        pair<iterator, bool> Insert(const pair<K, V>& kv)
        {
            return _t.Insert(kv);
        }

        //为了实现operator[] 多加一个迭代器返回 返回value
        V& operator[](const K& key)
        {
            pair<iterator, bool> ret = _t.Insert(make_pair(key, V()));//缺省
            return ret.first->second;
            //ret.first拿到迭代器 迭代器->second对应value
        }

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

    void test_map()
    {
        map<int, int> m;
        m.Insert(make_pair(1, 1));
        m.Insert(make_pair(3, 3));
        m.Insert(make_pair(10, 10));
        m.Insert(make_pair(5, 5));
        m.Insert(make_pair(6, 6));

        map<int, int>::iterator it = m.begin();
        while (it != m.end())
        {
            cout << it->first << ":" << it->second << endl;
            ++it;
        }
        cout << endl;

        //支持范围for
        //for (auto kv : m)
        //{
        //	cout << kv.first << ":" << kv.second << endl;
        //}
        //cout << endl;

        //统计次数
        string strs[] = { "西瓜","樱桃","西瓜","苹果","西瓜","西瓜","西瓜","苹果" };
        map<string, int> countMap;
        for (auto& str : strs)
        {
            countMap[str]++;
            //第一次出现会先插入并同时返回Key所在的Value 然后value++  
            //第二次只返回Key所在的Value 然后value++ 
        }

        for (auto kv : countMap)
        {
            cout << kv.first << ":" << kv.second << endl;
        }
        cout << endl;
    }
}

范围for以及计数都可以使用

3.测试

#include "MyMap.h"
#include "MySet.h"

int main()
{
    szh::test_map();
    cout << endl;
    szh::test_set();
    return 0;
}

  

【C++】17.map和set的模拟实现 完

努力的小恒
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Map复制给新Map时，用 “=、clone、还是putAll”？论Map的深复制和浅复制
m0_54866636的博客
04-06 1255
目录 使用场景 尝试过的办法 1. “=”赋值 2. 使用.putAll()方法 3. 使用.clone()方法 测试用例 测试用例源码 使用场景 在我们最初使用map复制开发业务代码时，通常会踩到深浅复制（拷贝）这个坑里，比如我，在Map复制时 （如：Map<String, String> new_Map = old_Map） 出现过以下两类问题： 1.使用Map<String, String> new_Map = old_Map 操作，当修改new_Map属性后，ol
C++17新特性个人总结
热门推荐
我的博客
05-20 3万+
目录 C++17 1 关键字 1.1 constexpr 1.2 static_assert 1.3 auto 1.4 typename 1.5 inline 2 语法 2.1 折叠表达式 2.2 结构化绑定 2.3 允许非类型模板参数进行常量计算 2.4 条件分支语句初始化 2.5 聚合初始化 2.6 嵌套命名空间 2.7 lambda表达式捕获*this的值...
C++之STLmap和set的模拟实现
小赵小赵福星高照的博客
03-21 950
模拟实现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++红黑树模拟实现map和set
~
04-01 3761
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++STL之map、set的使用和模拟实现
溟洵的博客
01-29 1399
本章主要讲了map、set是如何使用的，以及map、set如何底层实现相较于前面的章节本章更加考验你的逻辑能力来进行封装，还能帮助对大体框架的有更加好的了解。
【C++】map 和 set
在平淡的日子里寻找存在的价值
03-24 1064
map/multimap 的使用以及 set/multiset 的使用
【c++】map和set的模拟实现
Quietcoder的博客
05-24 1285
🔥个人主页Quitecoder🔥c++笔记仓不断完善红黑树功能，最后封装模拟实现。
【C++进阶】map和set模拟实现
weixin_47132900的博客
07-22 142
相关代码的实现：map和set模拟实现
【C++】map 和 set 的模拟实现
joy.728的博客
01-21 1361
本篇博客主要改造了之前模拟实现的红黑树以及将改造后的红黑树模拟实现出 map 和 set等等。
C++ map和set
m0_61548909的博客
08-12 1148
问题：当key不在map中时，通过operator获取对应value时会发生什么问题？注意：在元素访问时，有一个与operator[]类似的操作at()(该函数不常用)函数，都是通过key找到与key对应的value。
map和set的模拟实现
06-06
封装红黑树，模拟SLT源码实现，封装出map和set
c-c++教程.pdf
03-09
4. **C++标准程序库**：标准模板库（STL）的使用，包括容器（如vector，list，set，map等）、迭代器、算法库等。 5. **C++编程实践**：包括上机实践、编程题解、实例分析，帮助学习者通过实际操作掌握理论知识。 6...
全国计算机等级考试二级C++模拟试题及答案.pdf
07-14
常见的STL容器有vector、list、set和map等 C.STL中的算法如sort、find、copy等可以直接作用于数组和容器 D.STL不支持泛型编程 【答案】D 30.C++中的流类库包括( ) A.stdin、stdout、stderr B.iostream、fstream、...
C++提高编程.docx
04-14
为了提高C++编程技能，理解和掌握一些高级特性至关重要，其中包括模板和STL（Standard Template Library，标准模板库）。 **1. 模板** 模板是C++中的一个重要特性，它允许程序员创建泛型代码，可以处理不同数据...
字节后端开发offer持有者模拟面试总结
04-26
9. **STL中的vector、map和set**： - vector是一个动态数组，支持随机访问，插入和删除元素效率较低。 - map是一个关联容器，以键值对形式存储数据，提供了高效的查找功能。 - set也是关联容器，包含唯一的元素，...
C++ 内存分配可视化
最新发布
一个大佬的博客
06-24 655
注：宽度表示生存时间(黑色表示泄漏)，高度表示内存占用大小，颜色表示每次调用地址。
什么野指针（c++）
qq_35374791的博客
06-24 6800
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
C++ TheadPool 线程池实现
GodJhin的博客
06-21 840
此情况发生情形3且设置了任务缓冲队列大小后面，主程序添加第N个任务，添加后发现池子中的线程用完了，任务缓冲队列也满了，于是进入等待状态、等待任务缓冲队列中的任务腾空通知。此情况基于情形1，所有工作线程已处在等待状态，主线程开始添加三个任务，添加后通知(notif())唤醒线程池中的线程开始取(take())任务执行. 此时的任务缓冲队列还是空。此情况发生情形2后面，所有工作线程都在工作中，主线程开始添加第四个任务，添加后发现现在线程池中的线程用完了，于是存入任务缓冲队列。
makefile文件编写（C）
baidu_34971492的博客
06-24 223
这个Makefile定义了如何编译和链接你的程序。CC变量指定了编译器（这里是gcc），CFLAGS变量包含了编译器的标志，比如警告选项和调试信息，LDFLAGS变量用于链接时的选项。运行Makefile：在命令行中运行make命令，Makefile会根据其规则自动编译和链接你的程序。
unordered_map和unordered_set的模拟实
10-07
unordered和unordered_set是C++标准库中的关联式容器。它们的模拟实现基于哈希表的数据结构。哈希表通过将关键字映射到表中的一个位置来进行访问，从而实现快速的查找和插入操作。 unordered_map是存储键值对的关联...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力的小恒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值