有关背景和set的介绍可以点击了解C++ set，接下来介绍map
1. map的介绍
1. map
是关联容器，它按照特定的次序
(
按照
key
来比较
)
存储由键值
key
和值
value
组合而成的元素。
2.
在
map
中，键值
key
通常用于排序和唯一地标识元素，而值
value
中存储与此键值
key
关联的内容。键值key
和值
value
的类型可能不同，并且在
map
的内部，
key
与
value
通过成员类型value_type绑定在一起，为其取别名称为
pair: typedef pair<const key, T> value_type;
3.
在内部，
map
中的元素总是按照键值
key
进行比较排序的。
4. map
中通过键值访问单个元素的速度通常比
unordered_map
容器慢，但
map
允许根据顺序对元素进行直接迭代(
即对
map
中的元素进行迭代时，可以得到一个有序的序列
)
。
5. map
支持下标访问符，即在
[ ]
中放入
key
，就可以找到与
key
对应的
value
。
6. map
通常被实现为二叉搜索树
(
更准确的说：平衡二叉搜索树
(
红黑树
))
。
2. map的使用
1. map的模板参数说明
key:
键值对中
key
的类型
T
： 键值对中
value
的类型
Compare:
比较器的类型，
map
中的元素是按照
key
来比较的，缺省情况下按照小于来比较，一般情况下(
内置类型元素
)
该参数不需要传递，如果无法比较时
(
自定义类型
)
，需要用户自己显式传递比较规则(
一般情况下按照函数指针或者仿函数来传递
)
Alloc
：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的
空间配置器
2. map的构造
| 函数声明 | 功能介绍 |
| map() |
构造一个空的
map
|
3. map的迭代器
| 函数声明 |
功能介绍
|
|
begin()
和
end()
|
begin:
首元素的位置，
end
最后一个元素的下一个位置
|
|
cbegin()
和
cend()
|
与
begin
和
end
意义相同，但
cbegin
和
cend
所指向的元素不
能修改
|
|
rbegin()
和
rend()
|
反向迭代器，
rbegin
在
end
位置，
rend
在
begin
位置，其
++
和
--
操作与
begin
和
end
操作移动相反
|
|
crbegin()
和
crend()
|
与
rbegin
和
rend
位置相同，操作相同，但
crbegin
和
crend
所
指向的元素不能修改
|
4. map的容量与元素访问
| 函数声明 | 功能简介 |
|
bool empty ( ) const
| 检测map中的元素是否为空，是返回true，否则返回false |
|
size_type size() const
|
返回
map
中有效元素的个数
|
|
mapped_type& operator[ ] (const
key_type& k)
|
返回去
key
对应的
value
|
注意：在元素访问时，有一个与
operator[ ]
类似的操作
at()(
该函数不常用
)
函数，都是通过
key
找到与
key
对应的
value
然后返回其引用，不同的是：
当
key
不存在时，
operator[ ]
用默认
value
与
key
构造键值对然后插入，返回该默认
value
，
at()
函数直接抛异常
。
5. map中元素的修改
| 函数声明 |
功能简介
|
|
pair<iterator,bool> insert (
const value_type& x )
|
在
map
中插入键值对
x
，注意
x
是一个键值
对，返回值也是键值对：
iterator
代表新插入
元素的位置，
bool
代表释放插入成功
|
| void erase ( iterator position) |
删除
position
位置上的元素
|
|
size_type erase ( const
key_type& x )
|
删除键值为
x
的元素
|
|
void erase ( iterator first,
iterator last )
|
删除
[first, last)
区间中的元素
|
|
void swap (
map<Key,T,Compare,Allocator>&
mp )
|
交换两个
map
中的元素
|
|
void clear ( )
|
将
map
中的元素清空
|
| iterator find ( const key_type& x) |
在
map
中插入
key
为
x
的元素，找到返回该元
素的位置的迭代器，否则返回
end
|
|
const_iterator find ( const
key_type& x ) const
|
在
map
中插入
key
为
x
的元素，找到返回该元
素的位置的
const
迭代器，否则返回
cend
|
|
size_type count ( const
key_type& x ) const
|
返回
key
为
x
的键值在
map
中的个数，注意
map
中
key
是唯一的，因此该函数的返回值
要么为
0
，要么为
1
，因此也可以用该函数来
检测一个
key
是否在
map
中
|
3.map的模拟实现
首先我们要使用红黑树进行封装map即可，如下是RBTree.cpp的文件，有关红黑树的详细介绍，可以点击了解C++ 红黑树。
#include <iostream>
#include <vector>
using namespace std;
namespace rbtree
{
enum Color
{
RED,
BLACK,
};
//当我们需要存储键值对，那么T就是pair<K, V>
//当我们只存储key值，那么T就是K
template <class T>
struct RBTreeNode
{
//构造函数
RBTreeNode(T data)
:_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _data(data)
, _col(RED)
{}
//成员变量
RBTreeNode* _left;
RBTreeNode* _right;
RBTreeNode* _parent;
T _data;//节点数据
Color _col;//颜色
};
//实现迭代器
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);
}
bool operator==(const Self& s)const
{
return _node == s._node;
}
bool operator!=(const Self& s)const
{
return _node != s._node;
}
//前置++
Self& operator++()
{
//如果右子树不为空，说明该树未取完，要取右子树的最左结点
if (_node->_right)
{
Node* left = _node->_right;
while (left->_left)
{
left = left->_left;
}
_node = left;
}
//右子树为空，说明该树已经取完，要回到cur为左孩子的parent
else
{
Node* cur = _node, * parent = cur->_parent;
while (parent && parent->_right == cur)
{
cur = parent;
parent = cur->_parent;
}
_node = parent;
}
return *this;
}
//后置++
Self operator++(int)
{
Self old = new Self(_node);
//如果右子树不为空，说明该树未取完，要取右子树的最左结点
if (_node->_right)
{
Node* left = _node->_right;
while (left->_left)
{
left = left->_left;
}
_node = left;
}
//右子树为空，说明该树已经取完，要回到cur为左孩子的parent
else
{
Node* cur = _node, * parent = cur->_parent;
while (parent && parent->_right == cur)
{
cur = parent;
parent = cur->_parent;
}
_node = parent;
}
return old;
}
//前置--
Self& operator--()
{
Self old = new Self(_node);
//如果左子树不为空，说明该树未取完，要取左子树的最右结点
if (_node->_left)
{
Node* right = _node->_left;
while (right->_right)
{
right = right->_right;
}
_node = right;
}
//左子树为空，说明该树已经取完，要回到cur为右孩子的parent
else
{
Node* cur = _node, * parent = cur->_parent;
while (parent && parent->_left == cur)
{
cur = parent;
parent = cur->_parent;
}
_node = parent;
}
return old;
}
//后置--
Self operator--(int)
{
//如果左子树不为空，说明该树未取完，要取左子树的最右结点
if (_node->_left)
{
Node* right = _node->_left;
while (right->_right)
{
right = right->_right;
}
_node = right;
}
//左子树为空，说明该树已经取完，要回到cur为右孩子的parent
else
{
Node* cur = _node, * parent = cur->_parent;
while (parent && parent->_left == cur)
{
cur = parent;
parent = cur->_parent;
}
_node = parent;
}
return *this;
}
};
//前面的K用于传入key的类型，后面的T用于传入红黑树存储的数据类型。
keyOfT仿函数，取出T对象中的key,用于比较
template<class K, class T, class KeyOfT>
class RBTree
{
typedef typename RBTreeNode<T> Node;
typedef typename RBTreeIterator<T, T&, T*> iterator;
public:
//构造函数
RBTree()
:_root(nullptr)
{}
//析构函数
~RBTree()
{
Destroy(_root);
_root = nullptr;
}
iterator begin()
{
Node* left = _root;
while (left->_left)
{
left = left->_left;
}
return iterator(left);
}
iterator end()
{
return iterator(nullptr);
}
pair<iterator, bool> Insert(const T& data)
{
KeyOfT kot;
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return make_pair(iterator(_root), true);
}
//找位置插入
Node* cur = _root, * parent = _root;
while (cur)
{
if (kot(data) < kot(cur->_data))
{
parent = cur;
cur = cur->_left;
}
else if (kot(data) > kot(cur->_data))
{
parent = cur;
cur = cur->_right;
}
else
{
return make_pair(iterator(cur), false);
}
}
cur = new Node(data);
cur->_parent = parent;
if (kot(data) < kot(parent->_data))
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
Node* ret = cur;
//检查颜色(当连续出现两个红色时需要调整)
while (parent && parent->_col == RED)
{
Node* grandparent = parent->_parent;
if (parent == grandparent->_left)
{
Node* uncle = grandparent->_right;
//如果uncle存在且为红，则将parent和uncle变黑，grandparent变红
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandparent->_col = RED;
//继续向上检查
cur = grandparent;
parent = cur->_parent;
}
//uncle不存在或者为黑
else
{
//将grandparent右旋，grandparent变为红,parent变为黑
if (cur == parent->_left)
{
RotateR(grandparent);
grandparent->_col = RED;
parent->_col = BLACK;
}
//将parent左旋，grandparent右旋，将cur变为黑，grandparent变为红
else
{
RotateL(parent);
RotateR(grandparent);
grandparent->_col = RED;
cur->_col = BLACK;
}
//此时最上面的结点为黑，可以直接结束
break;
}
}
else
{
Node* uncle = grandparent->_left;
//如果uncle存在且为红，则将parent和uncle变黑，grandparent变红
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandparent->_col = RED;
//继续向上检查
cur = grandparent;
parent = cur->_parent;
}
//uncle不存在或者为黑
else
{
//将grandparent左旋，grandparent变为红,parent变为黑
if (cur == parent->_right)
{
RotateL(grandparent);
grandparent->_col = RED;
parent->_col = BLACK;
}
//将parent右旋，grandparent左旋，将cur变为黑，grandparent变为红
else
{
RotateR(parent);
RotateL(grandparent);
grandparent->_col = RED;
cur->_col = BLACK;
}
break;
}
}
}
//把根节点变为黑
_root->_col = BLACK;
return make_pair(iterator(ret), true);
}
bool _IsRBTree(Node* root, int count, int blacknum)
{
if (root == nullptr)
{
if (count != blacknum)
{
return false;
}
return true;
}
if (root->_col == BLACK)
{
count++;
}
return _IsRBTree(root->_left, count, blacknum) &&
_IsRBTree(root->_right, count, blacknum);
}
bool IsRBTree()
{
if (_root->_col == RED)
{
return false;
}
int blacknum = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
{
blacknum++;
}
cur = cur->_left;
}
return _IsRBTree(_root, 0, blacknum);
}
void _InOrder(Node* root)
{
KeyOfT kot;
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << kot(root->_data) << " ";
_InOrder(root->_right);
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void Destroy(Node* root)
{
if (root == nullptr)
{
return;
}
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
//左单旋
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
Node* grandparent = parent->_parent;
parent->_right = subRL;
if (subRL)
{
subRL->_parent = parent;
}
subR->_left = parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
}
else
{
if (grandparent->_left == parent)
grandparent->_left = subR;
else
grandparent->_right = subR;
}
subR->_parent = grandparent;
}
//右单旋
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
Node* grandparent = parent->_parent;
parent->_left = subLR;
if (subLR)
{
subLR->_parent = parent;
}
subL->_right = parent;
parent->_parent = subL;
if (parent == _root)
{
_root = subL;
}
else
{
if (grandparent->_left == parent)
grandparent->_left = subL;
else
grandparent->_right = subL;
}
subL->_parent = grandparent;
}
//左右双旋
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
}
//右左双旋
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = parent->_left;
int bf = subRL->_bf;
RotateR(subR);
RotateL(parent);
}
Node* _root;
};
};
map.cpp文件如下
#include "RBTree.cpp"
namespace lbk
{
template <class K, class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
typedef typename rbtree::RBTreeIterator<pair<K, V>, pair<K, V>&, pair<K, V>*> iterator;
public:
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _t.Insert(kv);
}
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
void InOrder()
{
_t.InOrder();
}
private:
//前面的K用于传入key的类型，后面的T用于传入红黑树存储的数据类型。
//红黑树中存储的值不可以改变，应加上const
rbtree::RBTree<K, const pair<K, V>, MapKeyOfT> _t;
};
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
