《STL源码剖析》阅读笔记1
排列组合算法
next_permutation
作用：获得[first,last）所表示序列的下一个排列组合
如果没有，返回false;
否则返回true
算法：
1- 从最尾端往前搜索两个相邻元素，零第一个元素为*i,第二个为*ii,并满足：*i<*ii;
2- 再从尾端开始往前检验，找出第一个大于*i的元素，令为*j,对调i,j指向元素；
3- 将ii后的所有元素颠倒
例子
char*版本代码：
bool next_permutation(char*first,char*last)
{
if(first==last)return false;//空区间
char *i=first;
++i;
if(i==last)return false;//只有一个元素
i=last;//尾端
--i;
for(;;)
{
char *ii=i;
--i;
if(*i<*ii)
{
char *j=last;
while(!(*i<*--j));
swap(*i,*j);
reverse(ii,last);
return true;
}
if(i==first)
{
reverse(first,last);
return false;
}
}
}
prev_ permutation
算法：
1-尾端往前搜索两个相邻元素，零第一个元素为*i,第二个为*ii,并满足：*i>*ii;
2-端开始往前检验，找出第一个小于素，令为*j,对调i,j指向元素；
3-ii的所有元素颠倒
char*版本：
bool prev_permutation(char*first,char*last)
{
if(first==last)return false;//空区间
char *i=first;
++i;
if(i==last)return false;//只有一个元素
i=last;//尾端
--i;
for(;;)
{
char *ii=i;
--i;
if(*i>*ii)
{
char *j=last;
while(!(*i>*--j));
swap(*i,*j);
reverse(ii,last);
return true;
}
if(i==first)
{reverse(first,last);return false;}
}
}
随机重排数组
random_shuffle
for i=1~n-1
swap(a[i],a[rand()%(i+1)])
快速计算x的n次幂 power()的实现
x^n(n>=0)
template <class T>
T power (T x,int n)
{
if(n==0)return 1;
else
{
Tresult=1;
if(n&1!=0)//n为偶数
{//result=x,n=n-1或者n=n&0;
result=x;n=n&0;
}
//n为奇数或偶数时的公共部分
while(n&1==0)
{
x=x*x;
n>>=1;
}
result*=x;
}
return result;
}
模仿STL的版本
template <class T>
T power (T x,int n)
{
if(n==0)return 1;
else
{
while((n&1==0))//偶数
{
n>>=1;
x=x*x;
}
T result=x;
n>>=1;
while(n!=0)
{
x=x*x;
if(n&1!=0)奇数
result=result*x;
n>>=1;
}
result
}
}
heap算法和优先级队列
push_heap(first,last)
pop_heap(first,last){adjust_heap}
sort_heap(first,last){一直使用pop_heap直至没有元素为止}
make_heap(first,last){调用adjust_heap}
建立堆
make_heap(_First,_Last, _Comp)
1-默认是建立最大堆的。
在堆中添加数据
push_heap(_First, _Last)
要先在容器中加入数据，再调用push_heap ()
在堆中删除数据
pop_heap(_First,_Last)
要先调用pop_heap()再在容器中删除数据
堆排序
sort_heap(_First,_Last)
用法
int a[9]={1-9}:
vector<int>myvec(a,a+9);
make_heap(myvec.begin(),myvec.end());
///直接改变myvec
优先级队列=vector+heap算法
构造函数---make_heap算法,make_heap(c.begin,c.end(),comp)
push---------（1，低层容器的push_back插入末端，
2，使用push_heap算法重排heap, push_heap(c.begin,c.end(),comp)
pop---------(1,重排heap,pop_heap(c.begin,c.end(),comp)
2,底层容器的pop_back()弹出元素， c.pop_back())
自定义类使用优先级队列
通过对结构体重载operator()：
1- 定义函数对象
2- 重新定义operator<函数
例子：程序功能是模拟排队过程，每人有姓名和优先级，优先级相同则比较姓名，
开始有5个人进入队列，然后队头2个人出队，再有3个人进入队列，
最后所有人都依次出队，程序会输出离开队伍的顺序。
将上面结构体Node改成类
使用set容纳自定义类/结构体
使用set容纳自定义类/结构体
set模板需要3个泛型参数：
template<class T, class C, class A>class set;
第一个T 是元素类型，必选；
第二个C 指定元素比较方式，缺省为 Less<T>, 即使用 < 符号比较；
第三个A 指定空间分配对象，一般使用默认类型。
因此:对于第2个泛型参数
(1) 如果使用默认值，自定义元素类型需要重载< 运算操作；
(2)不使用默认值，则比较对象必须具有() 操作，即自定义函数对象：
bool operator()(const T &a, const T&b)
即自定义一个比较函数/函数对象
map使用自定义类-----看模板参数
所以作为关键字，起码必须有“<”这个比较操作符。
1-int，float，enum，size_t等等简单关键字，都有内置的比较函数，与map搭没什么问题。
2-自定义类型，必须明确定义“<”比较操作符，作为第三个参数。
使用map时，注意以下两点，同时这两点也是改错的方法：
a） 关键字明确定义“<”比较操作符
b） 没有“<”比较操作符，自定义仿函数替代第三个参数Compare，该仿函数实现“()”操作符，提供比较功能。插入时使用
map<pair<int,int>,int,comp>res;
res.insert(make_pair(12,33),33);
res.insert(make_pair(122,333),333);
capacity,size
capacity
容器增长前，能够容纳的元素总数；
只有连续存储的容器才有容量概念（vector,deque,string）,list不需要；
size
容器当前存储的元素数量；
注：vector默认的容量初始值，增长规则依赖编译器
vector存储自定义对象
自定义对象必须满足：
1， 默认构造函数（默认或自定义的）
2， 可用的拷贝构造，赋值函数（默认或自定义的）
自己的理解：如果对vector排序的话，还需要定义operator<,==等操作符
deque
双向队列-----双向开口的连续线性空间；
高效的在头尾两端插入和删除元素；
deque的实现
内部会维护一个map（注意！不是STL中的map容器）即一小块连续的空间，该空间中每个元素都是指针，指向另一段（较大的）区域，这个区域称为缓冲区，缓冲区用来保存deque中的数据。因此deque在随机访问和遍历数据会比vector慢。
注意一点。对于deque和vector来说，尽量少用erase(pos)和erase(beg,end)。因为这在中间删除数据后会导致后面的数据向前移动，从而使效率低下。
与vector比：
1-高效的首段插入/删除，2-内存管理
deque的中find自定义的类型
以调用find()在deque中查找：
对应自定义的类和结构须添加：
booloperator == (const MyClass &other) const 成员函数；
或booloperator ==(const MyClass &one, const MyClass &another) 全局函数。内存泄露
如果容器中含有元素：
则程序退出前须清空调用deque的clear()或~deque()，否则出现内存泄露。
如存储的是指针类型deque<MyClass*>：
每个指针对应一个堆内存。
1-则需要使用遍历每一个元素并调用delete *iterator;来释放指针指向内存。
2-然后在清空容器(deque的clear()或~deque())