//
// set map.cpp
// 笔记
//
// Created by fam on 15/3/23.
//
//
//---------------------------15/03/23----------------------------
//set
{
/*
set概述：
1:所有的元素都会被自动排序，
2:所有的元素只有"键"没有“值” 或者说他们的“值”就是“键”
3:不允许出现两个相同的键值
4:不能通过迭代器改变set的值，因为set的值就是键，
如果可以改变，我们要先删除键，平衡二叉树，再加改变后的键，再平衡
这么做严重破坏了set的组织，iterator也会变得无效，到底是指向之前的位置
还是指向改变后的位置等等。所以stl中不允许改变set的值。
5:set用RB_tree作为底层机制(废话，不然干嘛花大篇幅介绍RB_tree)
*/
//class
template<class Key, class Compare = less<Key>,
class Alloc = alloc>
class set
{
public:
typedef Key key_type;
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
private:
//identity<value_type> 可以根据key值得到value值
typedef rb_tree<key_type, value_type,
identity<value_type>, key_compare, Alloc> rep_type;
rep_type t;
public:
//由于上面说的set不能改变值，所以指针和迭代器引用这些 全都用RB_tree中的const类型的来指定
typedef typename rep_type::const_pointer pointer;
typedef typename rep_type::const_pointer const_pointer;
typedef typename rep_type::const_reference reference;
typedef typename rep_type::const_reference const_reference;
typedef typename rep_type::const_iterator iterator;
typedef typename rep_type::const_iterator const_iterator;
typedef typename rep_type::const_reverse_iterator reverse_iterator;
typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
typedef typename rep_type::size_type size_type;
typedef typename rep_type::difference_type difference_type;
set() : t(Compare()){}
explicit set(const Compare& comp) : t(comp){}
//inset_unique 是不允许相同值出现的插入
template<class InputIterator>
set(InputIterator first, InputIterator last)
: t(Compare()){ t.insert_unique(first, last);}
template<class InputIterator>
set(InputIterator first, InputIterator last,const Compare& comp)
: t(comp){t.insert_unique(first, last);}
set(const set<Key, Compare, Alloc>& x): t(x.t){}
set<Key, Compare, Alloc>& operator=(const set<Key, Compare, Alloc>& x)
{
t = x.t;
return *this;
}
key_compare key_comp() const { return t.key_comp();}
//set中的值就是键 所以调用key_comp()
value_compare value_comp() const {return t.key_comp();}
iterator begin() const {return t.begin();}
iterator end() const {return t.end();}
reverse_iterator rbegin() const {return t.rbegin();}
reverse_iterator rend() const {return t.end();}
bool empty() const { return t.empty();}
size_type size() const { return t.size();}
size_type max_size() const { return t.max_size();}
void swap(set<Key, Compare, Alloc>& x) { t.swap(x.t);}
//insert erase
typedef pair<iterator, bool> pair_interator_bool;
pair<iterator, bool> inset(const value_type& x)
{
pair<typename rep_type::iterator, bool> p =t.insert_unique(x);
return pair<iterator, bool>(p.first, p.second);
}
iterator insert(iterator position, const value_type& x)
{
typedef typename rep_type::iterator rep_iterator;
return t.insert_unique((rep_iterator&)position, x);
}
template<class InputIterator>
void insert(InputIterator first, InputIterator last)
{
t.insert_unique(first, last);
}
void erase(iterator position)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)position);
}
size_type erase(const key_type& x)
{
return t.erase(x);
}
void erase(iterator first, iterator last)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)first, (rep_iterator&)last);
}
void clear() { t.clear();}
//
iterator find(const key_type& x) const { return t.find(x); }
size_type count(const key_type& x) const { return t.count(x); }
iterator lower_bound(const key_type& x) const
{
return t.lower_bound(x);
}
iterator upper_bound(const key_type& x) const
{
return t.upper_bound(x);
}
pair<iterator,iterator> equal_range(const key_type& x) const
{
return t.equal_range(x);
}
friend bool operator== __STL_NULL_TMPL_ARGS (const set&, const set&);
friend bool operator< __STL_NULL_TMPL_ARGS (const set&, const set&);
};
template<class Key, class Compare, class Alloc>
inline bool operator==(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t == y.t;
}
template<class Key, class Compare, class Alloc>
inline bool operator<(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t < y.t;
}
// 总结
//没什么好总结的，这里只是不断调用底层的东西，没有技术可言
}
//map
{
/*
map概述：
和set不同的就是，多了一个值的概念，每一个键都可以存储一个实值
排序是根据key(键)来排序的。一般都是根据key来取其中的值。
和set一样的原理，我们不能改变键。和set不同的是，可以改变data(实值)
实值只是节点所存储的东西，当然可以改，改了不会影响排序
*/
//struct pair
template<class T1, class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair() : first(T1()), second(T2()){}
pair(const T1& a,const T2& b) : first(a), second(b){}
};
template<class Key, class T, class Compare = less<Key>,
class Alloc = alloc>
class map
{
public:
typedef Key key_type;
typedef T data_type;
typedef T mapped_type;
typedef pair<const Key, T> value_type;
typedef Compare key_compare;
typedef Compare value_compare;
class value_compare
: public binary_function<value_type, value_type, bool>
{
friend class map<Key, T, Compare, Alloc>;
protected:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
bool operator()(const value_type& x, const value_type& y) const
{
return comp(x.first, y.first);
}
};
private:
typedef rb_tree<key_type, value_type,
select1st<value_type>, key_compare, Alloc> rep_type;
rep_type t;
public:
typedef typename rep_type::pointer pointer;
typedef typename rep_type::const_pointer const_pointer;
typedef typename rep_type::reference reference;
typedef typename rep_type::const_reference const_reference;
typedef typename rep_type::iterator iterator;
typedef typename rep_type::const_iterator const_iterator;
typedef typename rep_type::reverse_iterator reverse_iterator;
typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
typedef typename rep_type::size_type size_type;
typedef typename rep_type::difference_type difference_type;
map() : t(Compare()){}
explicit map(const Compare& comp) : t(comp){}
//inset_unique 是不允许相同值出现的插入
template<class InputIterator>
map(InputIterator first, InputIterator last)
: t(Compare()){ t.insert_unique(first, last);}
template<class InputIterator>
map(InputIterator first, InputIterator last,const Compare& comp)
: t(comp){t.insert_unique(first, last);}
map(const set<Key, Compare, Alloc>& x): t(x.t){}
map<Key, Compare, Alloc>& operator=(const map<Key, Compare, Alloc>& x)
{
t = x.t;
return *this;
}
key_compare key_comp() const { return t.key_comp();}
value_compare value_comp() const { return t.value_compare(t.key_comp());}
iterator begin() const { return t.begin();}
iterator end() const { return t.end();}
reverse_iterator rbegin() const { return t.rbegin();}
reverse_iterator rend() const { return t.end();}
bool empty() const { return t.empty();}
size_type size() const { return t.size();}
size_type max_size() const { return t.max_size();}
void swap(set<Key, Compare, Alloc>& x) { t.swap(x.t);}
//map可以根据 键 来取 值， 如果不存在就插入一个新的 键值对
T& operator[] (const key_type& k)
{
return (*((insert(value_type(k,T()))).first)).second;
}
//insert erase
pair<iterator, bool> inset(const value_type& x)
{
pair<typename rep_type::iterator, bool> p =t.insert_unique(x);
return pair<iterator, bool>(p.first, p.second);
}
iterator insert(iterator position, const value_type& x)
{
typedef typename rep_type::iterator rep_iterator;
return t.insert_unique((rep_iterator&)position, x);
}
template<class InputIterator>
void insert(InputIterator first, InputIterator last)
{
t.insert_unique(first, last);
}
void erase(iterator position)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)position);
}
size_type erase(const key_type& x)
{
return t.erase(x);
}
void erase(iterator first, iterator last)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)first, (rep_iterator&)last);
}
void clear() { t.clear();}
//
iterator find(const key_type& x) const { return t.find(x); }
size_type count(const key_type& x) const { return t.count(x); }
iterator lower_bound(const key_type& x) const
{
return t.lower_bound(x);
}
iterator upper_bound(const key_type& x) const
{
return t.upper_bound(x);
}
pair<iterator,iterator> equal_range(const key_type& x) const
{
return t.equal_range(x);
}
friend bool operator== __STL_NULL_TMPL_ARGS (const set&, const set&);
friend bool operator< __STL_NULL_TMPL_ARGS (const set&, const set&);
};
template<class Key, class Compare, class Alloc>
inline bool operator==(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t == y.t;
}
template<class Key, class Compare, class Alloc>
inline bool operator<(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t < y.t;
}
/*
总结:
map和set不同的是有了data这个概念，并且可以更改这个data值了
set插入时插的就是key， map插入时插的是value(键值对)
插入时，函数会调用keyofvalue仿函数取得value的key
之后排序会根据key_compare(也就是模版参数中的Compare)来比较key的大小
最后都是用key来比较的，不同的是set存的值也是key，map存的值是data。
*/
}
//multiset 和multimap
/*
这两个容器和之前的基本相同，不同的就是把inset_unique改成inset_equel
具体的底层实现在RB_tree 中已经实现了，只要调用就行了
*/