数据结构利器之私房STL（中）
索引
这篇文章 http://www.cnblogs.com/daoluanxiaozi/archive/2012/12/02/confidential-stl.html 由于严重违反了『博客园首页』的相关规则，因此笔者改将《私房STL》系列的每一篇都整合到博客园中，取消外链的做法。另，考虑篇幅的问题，此系列文章将分为上、中、下。此篇为《数据结构利器之私房STL（中）》。喜欢就顶下:-)
此系列的文章适合初学有意剖析STL和欲复习STL的同学们。
私房STL之map和set
一句话set：容器set底层是由RB_TREE实现的，它和（deque--->stack、queue）模式一样；色set的元素不允许重复；set中键值就是实值，实值就是键值，而键值是不可以更改的（但MS STL不这样做），所以set不允许对其中的元素进行更新；
一句话map：容器map底层也由RB_TREE实现，它和（deque--->stack、queue）模式一样；map中一个键值对应一个实值，不允许键值上的重复，内部是按键值来进行排序存储的，其中键值不允许被更改。
网络上有关于红黑树详细的解说，特别是复杂的红黑树元素操作算法，推荐@JULY 的文章：http://blog.csdn.net/v_JULY_v/article/details/6105630。本文主要介绍STL set/map的用法和笔者对其在实现上技巧实现技法的摘录，欢迎斧正。
set和map的创建与遍历
set和map都是由非线性空间来存储的，属于Bidrectional Iterator;测试添加元素的时候，故意添加已存在的键值，发现被拒绝，RB_TREE内部有insert_equal()和insert_unique()两个版本，set/map都调用后者。
set：
...... set<int> is; is.insert(7); is.insert(5); is.insert(6); is.insert(4); is.insert(3); is.insert(3); /*here.*/ set<int>::iterator beg = is.begin(), end = is.end(),ite; for(ite = beg; ite != end; ite++) cout << *ite << " "; cout << endl;/*3 4 5 6 7*/ ......
map：
map<int,int> im; im.insert(pair<int,int>(7,700)); im.insert(pair<int,int>(5,500)); im.insert(pair<int,int>(6,600)); im.insert(pair<int,int>(4,400)); im.insert(pair<int,int>(3,300)); im.insert(pair<int,int>(3,300)); /*here.*/ map<int,int>::iterator beg = im.begin(), end = im.end(),ite; for(ite = beg; ite != end; ite++) cout << "<" <<ite->first << " " << ite->second << ">" << " "; cout << endl; /*<3 300> <4 400> <5 500> <6 600> <7 700>*/
set和map的查找
RB_TREE本身就是一个搜索树，加之它能时刻保持良好的平衡，所以查找效率高。set和map内部已经实现了find()查找。而STL <algorithm>find()效率低很多。
有趣的实现
在insert()函数中，会经常用到pair这个结构体，里头有两个元素：第一元素被作为键值，第二元素被作为实值。
/*摘自MS STL。*/
// TEMPLATE STRUCT pair
template<class _Ty1,
class _Ty2> struct pair
{ // store a pair of values
typedef pair<_Ty1, _Ty2> _Myt;
typedef _Ty1 first_type;
typedef _Ty2 second_type;
pair()
: first(_Ty1()), second(_Ty2())
{ // construct from defaults
}
......
_Ty1 first; // the first stored value
_Ty2 second; // the second stored value
};
有趣的地方是，它不仅仅用在insert()的参数中，还应用在insert()的返回值和map的“[]”运算符重载中。
typedef pair<iterator, bool> _Pairib; ...... _Pairib insert(const value_type& _Val);
所以在insert()过后，如果插入成功，_Pairib的iterator会指向元素插入的位置，bool被置为true；否则，iterator指向重复的元素的位置，且bool为false.所以，“[]”重载函数可以通过insert()间接实现的。但在MS STL中，它没有采用这种方法，其内部虽也通过insert()间接实现，但其采用以map<T1,T2>::iterator为返回值的insert()版本。
mapped_type& operator[](const key_type& _Keyval)
{ // find element matching _Keyval or insert with default mapped
iterator _Where = this->lower_bound(_Keyval);
if (_Where == this->end()
|| this->comp(_Keyval, this->_Key(_Where._Mynode())))
_Where = this->insert(_Where,
value_type(_Keyval, mapped_type()));
return ((*_Where).second);
}
一个关于set的疑问
set中键值就是实值，实值就是键值。既然这样，set中的元素就不允许被修改，一个测试：实践证明，set中的元素允许被改变，改变后，set内部对其视若无睹。
set<int> is; is.insert(7); is.insert(5); is.insert(6); is.insert(4); is.insert(3); is.insert(3); /*3 4 5 6 7*/ set<int>::iterator beg = is.begin(), end = is.end(),ite; *beg = 8; for(ite = beg; ite != end; ite++) cout << *ite << " "; cout << endl; /*8 4 5 6 7*//*居然可以修改，吓shi了*/ is.insert(100); for(ite = beg; ite != end; ite++) cout << *ite << " "; cout << endl; /*8 4 5 6 7 100*//*居然也不维护一下，吓shi了*/
原来是set的iterator迭代器被声明为一般的iterator，而不是const。
/*摘自MS STL。*/ typedef typename _Mybase::iterator iterator;
不仅如此，在set的模板声明中也可以看出端倪：
/*摘自MS STL。*/
template<class _Kty,
class _Pr = less<_Kty>,
class _Alloc = allocator<_Kty> >
class set
: public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, false> >
{ // ordered red-black tree of key values, unique keys
所以如果需要禁止用户通过迭代器修改键值，那么可以将迭代器声明为const：（笔者认为这样可行的）
typedef typename _Mybase::const_iterator iterator;
而map把关得很好，它强行将pair中的第一元素（注意，只是第一元素而已）定义为const：
/*摘自MS STL。*/
template<class _Kty,
class _Ty,
class _Pr = less<_Kty>,
class _Alloc = allocator<pair<const _Kty, _Ty> > >
class map
: public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> >
{ // ordered red-black tree of {key, mapped} values, unique keys
......
本文的后部分需要对STL源码有一定的了解。本文有待补充。
本文完 2012-10-16
私房STL之Hashtable
一句话之Hashtable：哈希表（散列表）能通过键值对数据进行访问的数据结构；其在C++0X标准中未出现，可能是考虑到哈希表效率低下，出于其广泛用于工程中，C++11将其纳入了标准库。C++11的新特性：http://en.wikipedia.org/wiki/C%2B%2B11，C++11中哈希表的说明：http://en.wikipedia.org/wiki/C%2B%2B11#Hash_tables；我们知道，通过哈希表来索引目标是很高效的，但这样会出现碰撞问题（即对不同的关键字可能得到同一哈希地址）。常用的解决碰撞的方法有四：线性探测、二次探测、再散列和开链法。而STL中的哈希表所采用的是开链法（也叫链地址法）。
- 哈希表
Hashtable的查找，插入，删除
在通过给定的键值计算出元素在Hashtable中的位置（O(1)就可以完成）时，行为就与单链表一样了，查找，插入和删除操作的平均开销都为O(N/2)。
=============================================
剩下的内容没有对哈希表模拟实验之类的内容（互联网有很多作者给出了很详细的分析，推荐一个：http://blog.csdn.net/morewindows/article/details/7330323），只描述解决碰撞的方法和哈希表的效率问题。
哈希表碰撞问题
这样假设，哈希表大小为N，哈希函数为Hash(elem)，计算哈希表地址时，取模N，意即：elem在哈哈希表地址是Hash(elem) % N。
线性探测的做法：计算哈哈希表地址得出Hash(elem) % N，如果此地址未被占用，那么插入；否则，探测(Hash(elem) + 1) % N 是否占用，如果未被占用，插入。否则继续探测下去。
二次探测的做法：同线性探测，计算哈希表地址得出Hash(elem) % N，如果此地址未被占用，那么插入；否则，探测(Hash(elem) + 1^2) % N，如果未被占用，插入。否则继续探(Hash(elem) + 2^2) % N。。。
再散列法：存在K个不同的哈希函数Hi = Hashi(elem) % M，k = 0,1,2,k-1。倘若第1个哈希函数不行，采用第2个，从而减少碰撞。
开链法的做法：属于（vector + single list）的模式，计算哈希表地址得出Hash(elem) % N，插入对应的单链表。
哈希表的效率
线性探测，1、需要表有足够大连续的空间，否则元素太多，就需要resize，效率不可观；2、在进行探测的空闲地址的时候，最坏的情况探测整个表，平均情况是整个表的一半，不可取。
二次探测，1、它同样需要有足够大的连续的空间；2、对线性探测的一种改进的地方，便是平方（二次方）探测，意即步长不再是n，而为n^2，这样能减少碰撞。
再散列法：1、它同样需要有足够大的连续的空间；2、增加计算量。
前三种都未能很好解决碰撞问题。
开链法，动态非连续空间（single list），不存在线性探测和二次探测的第一个问题；在确定地址过后，只需要对相应的single list作插入，删除，修改操作，这样碰撞的问题就转化为single list的寻访，速度可观。STL Hashtable就是采用开链法。
-
- 链地址法
后来我们将看到，STL中的hash_set和hash_map皆由Hashtable作为底层容器。
哈希表的应用
在数据结构的课堂便有这样的实验：统计文本单词出现的频率。我们可以创建单词哈希表，Hasn(word)定义为word中每个字符的ASCII码之和，通过它来确定单词在哈希表地址，进而进行统计。
另外，初学程序设计的同学都有设计学生管理系统的经历，现有需求“以学生姓名为关键字，如何建立查找表，使得根据姓名可以直接找到相应记录呢？”，这也是哈希表的一个应用。
本文完 2012-10-21
私房STL算法之全排列
全排列问题：从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m＝n时所有的排列情况叫全排列。譬如，考虑{a，b，c}的全排列有abc，acb，bac，bca，cab，cba六（3！）种情况。
首先要声明，STL没有实现全排列的函数，但描述了全排列的核心算法，分别是next_permutation和prev_permutation，两者实际上一样，只不过情况不同。全排列实现可以是递归和迭代两个版本。STL算法中的next_permutation便也是全排列算法迭代版本的核心。
递归实现全排列
递归实现全排列是一个经典的算法。
/*全排列递归版本*/
void foo1(char *str,int k,int n)
{
if(k == n) // print str when it reaches the last character.
{
cout << str << " ";
return;
}// if
for(int i=k; i<n; i++)
{
swap(str[k],str[i]);
foo1(str,k+1,n); // next character.
swap(str[k],str[i]);
}// for
}
abcd abdc acbd acdb adcb adbc bacd badc bcad bcda bdca bdac cbad cbda cabd cadb
cdab cdba dbca dbac dcba dcab dacb dabc 请按任意键继续. . .
迭代实现全排列
因为next_permutation和prev_permutation实际上换汤不换药，因此只描述next_permutation算法。在下笔之前，next_permutation()函数的作用是取下一个排列组合。同样，考虑{a，b，c}的全排列：abc，acb，bac，bca，cab，cba，以“bac”作为参考，那么next_permutation()所得到的下一个排列组合是bca，prev_permutation()所得到的前一个排列组合是“acb”，之于“前一个”和“后一个”，是按字典进行排序的。
next_permutation()算法描述：
- 从str的尾端开始逆着寻找相邻的元素，*i和*ii，满足*i<*ii；
- 接着，又从str的尾端开始逆着寻找一元素，*j，满足*i<*j（*i从步骤一中得到）；
- swap(*i,*j)；
- 将*ii之后（包括*ii）的所有元素逆转。
举个例子，需要找到“01324”的下一个排列，找到*i=2，*ii=4，*j=4，下一个排列即“01342”。再来找到“abfedc”的下一个排列，找到*i=b，*ii=f，*j=c，swap操作过后为“acfedb”，逆转操作过后为“acbdef”。
/*全排列迭代归版本*/
void reverse(char *str)
{
int len = strlen(str),i;
for(i=0; i<len/2; i++)
swap(*(str+i),*(str+len-1-i));
}
/*阶乘*/
int factorial(int n)
{
if(n == 1) return 1;
return n * factorial(n-1);
}
void foo2(char *p)
{
int len = strlen(p),cnt = 1;
char *i,*ii,*j;
cout << p << " ";
/*STL <algorithm> next_permutation()函数的核心算法*/
while(++cnt <= factorial(len))
{
i = p + len - 2,ii = p + len - 1,j = ii;
while(*i >= *ii) i--,ii--; /*find *i and *ii.*/
while(*i >= *j) j--; /*find *j.*/
swap(*i,*j); /*swap.*/
reverse(ii); /*reverse.*/
cout << p << " ";
}// while
}
abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda
cdab cdba dabc dacb dbac dbca dcab dcba 请按任意键继续. . .
prev_permutation()函数做法是一样的。
本文完 2012-10-22
私房STL算法之快速幂
STL中的pow用来计算某数的n幂次方。
幂运算中，如AK，需要作k次乘法，可以试着用二分法减少乘法的次数，乘法因为机器性能的不同所占的时钟周期数有10~40不等，所以降低乘法的次数，等于是节省CPU的资源，虽然在大多数情况这些无足轻重。
计算A23，可以依次计算A1b，A10b，A100b，A101b，A1010b，A1011b，A10110b，A10111b得到结果。在计算过程中，刻意将指数转化为二进制的形式，以更好理解二分法快速幂。这里可以呈现的是快速幂的递归算法，发现：
当指数n为偶数时，A^n = A^(n/2) * A^(n/2)；
当指数n为奇数时，A^n = A^(n/2) * A^(n/2) * A 。
从上面的例子中，即10111b为奇数，A10111b=(A10110b)2 * A；10110b为偶数，A10110b=(A1011b)2 ，依次类推。。。。
typedef unsigned int UINT;
UINT power(UINT A,UINT n)
{
if(n == 1)
return A;
UINT tmp = power(A,n>>1); /*calculate pow(A,n/2).*/
return (n & 1)
? tmp * tmp * A /*odd.*/
:tmp * tmp; /*even.*/
}
上面是递归的思路，迭代的也一样，同样可以举一个翔实的例子。计算A23，23用二进制展开：
23 = 1 * 24 + 0 * 23 + 1 * 22 + 1 * 21 + 1 * 20,
迭代从低位开始，第k位为0，即不操作；第k位为1，tmp *2k-1。
UINT power(UINT A,UINT n)
{
UINT tmp = 1,base = 2;
while(n)
{
if(n&1) /*低位为1*/
tmp *= base;
n >>= 1; /*右移*/
base <<= 1;
}// while
return tmp;
}
把原来O(N)降低为O(lnN)，很划得来。欢迎斧正。
本文完 2012-10-22
私房STL之hash_set和hash_map
一句话hash_set和hash_map：它们皆由Hashtable（Standard C++ Library未公开，只作为底层部件）作为底层容器， 所有的操作也都由Hashtable提供；咋看起来，好似与set和map有很大的关联，其实不大，只不过hash_set和hash_map有着“set键值就是实值，实值就是键值，map键值就是键值，实值就是实值”特征，姑且让set和map挂挂名:-)；
由此，hash_set内部元素也是未经排序的（从Hashtable的实现可知），而hash_map可以经由键值索引其对应实值（其重载了“[]”操作符）；由Hashtable的底层实现可知：hash_set和hash_map的查找效率和插入操作的平均时间开销都为O(N/2)。
hash_set和hash_map的创建与遍历
hash_set只需指定键值的类型，hash_map需指定键值和实值的类型。它们都可以像大多数的容器一样，通过迭代器，寻访元素。
...... hash_set<int> ihs; ihs.insert(1); ihs.insert(5); ihs.insert(6); ihs.insert(4); ihs.insert(3); ihs.insert(3); ihs.insert(100); ihs.insert(200); /*故意的*/ hash_set<int>::iterator beg = ihs.begin(), end = ihs.end(),ite; for(ite = beg; ite != end; ite++) cout << *ite << " "; cout << endl; ......
200 1 3 4 100 5 6
可证见hash_set拒绝插入重复元素（与set性质相同），未排序（违反set性质）。
...... hash_map<int,int> ihm; ihm.insert(pair<int,int>(1,100)); ihm.insert(pair<int,int>(2,200)); ihm.insert(pair<int,int>(3,300)); ihm.insert(pair<int,int>(4,400)); ihm.insert(pair<int,int>(5,500)); hash_map<int,int>::iterator beg = ihm.begin(), end = ihm.end(),ite; for(ite = beg; ite != end; ite++) cout << "<" << ite->first << "," << ite->second << ">" << " "; cout << endl; cout << "ihm[1] = " << ihm[1] << endl; /*可以通过键值索引*/ ......
<1,100> <2,200> <3,300> <4,400> <5,500>
ihm[1] = 100
hash_set和hash_map的查找
有Hashtable的实现可知，hash_set和hash_map的平均查找效率一样很高，各自内部有实现find()查找函数，无需使用从头至尾遍历的STL <algorithm>find()函数。Standard C++ Library中的实例：http://msdn.microsoft.com/en-US/library/ea54hzhb(v=vs.80).aspx
建议
hash_set和hash_map还实现很多函数，给出参考链接：http://msdn.microsoft.com/en-US/library/y49kh4ha(v=vs.80).aspx
外链 @MoreWindows 同学的文章：http://blog.csdn.net/morewindows/article/details/7330323，里头的亮点便是C++里头语法的细节问题。
本文完 2012-10-23