C++ STL库（6）

26. STL容器适配器

容器适配器就是将不适用的序列式容器（包括 vector、deque 和 list）变得适用。通过封装某个序列式容器，并重新组合该容器中包含的成员函数，使其满足某些特定场景的需要。容器适配器本质上还是容器，只不过此容器模板类的实现，利用了大量其它基础容器模板类中已经写好的成员函数。当然，如果必要的话，容器适配器中也可以自创新的成员函数。

STL 提供了 3 种容器适配器，分别为 stack 栈适配器、queue 队列适配器以及 priority_queue 优先权队列适配器：

容器适配器	基础容器筛选条件	默认使用的基础容器
stack	基础容器需包含以下成员函数：empty(); size(); back(); push_back(); pop_back(); 满足条件的基础容器有 vector、deque、list。	deque
queue	基础容器需包含以下成员函数：empty(); size(); front(); back(); push_back(); pop_front(); 满足条件的基础容器有 deque、list。	deque
priority_queue	基础容器需包含以下成员函数：empty(); size(); front(); push_back(); pop_back(); 满足条件的基础容器有vector、deque。	vector

27. stack栈适配器

1)创建

#include //stack>（其中 T 为存储元素的类型，Container 表示底层容器的类型）的形式位于头文件中
using namespace std;

stack<int> val1;

deque<int> deq{1,2,3};
stack<int> val2(deq); //val3中栈顶元素还是3

list<int> li{1,2,3};
stack<int, list<int>> val3(li);//指定使用list容器

stack<int> val4(val2); //使用 stack适配器给另一个stack进行初始化

2)成员函数

成员函数	功能
empty()	当 stack 栈中没有元素时，该成员函数返回 true；反之，返回 false。
size()	返回 stack 栈中存储元素的个数。
top()	返回一个栈顶元素的引用，类型为 T&。如果栈为空，程序会报错。
push(const T& val)	==先复制 val，再将 val 副本压入栈顶。==这是通过调用底层容器的 push_back() 函数完成的。
push(T&& obj)	==以移动元素的方式将其压入栈顶。==这是通过调用底层容器的有右值引用参数的 push_back() 函数完成的。
pop()	弹出栈顶元素。
emplace(arg…)	arg… 可以是一个参数，也可以是多个参数，但它们都只用于构造一个对象，并在栈顶直接生成该对象，作为新的栈顶元素。
swap(stack & other_stack)	==将两个 stack 适配器中的元素进行互换，==需要注意的是，进行互换的 2 个 stack 适配器中存储的元素类型以及底层采用的基础容器类型，都必须相同。

28. queue容器适配器

1)创建

#include//以模板类 queue>（其中 T 为存储元素的类型，Container 表示底层容器的类型）的形式位于头文件中
using namespace std;

queue<int> val1;

queue<int, list<int>> val2;//手动指定 queue 容器适配器底层采用的基础容器类型

dueue<int> val3{1,2,3};
queue<int> val4(val3); //用基础容器来初始化 queue 容器适配器，只要该容器类型和 queue 底层使用的基础容器类型相同即可

queue<int> val5(val4); //直接通过 queue 容器适配器来初始化另一个 queue 容器适配器

2)成员函数

成员函数	功能
empty()	如果 queue 中没有元素的话，返回 true。
size()	返回 queue 中元素的个数。
front()	==返回 queue 中第一个元素的引用。==如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
back()	==返回 queue 中最后一个元素的引用。==如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
push(const T& obj)	==在 queue 的尾部添加一个元素的副本。==这是通过调用底层容器的成员函数 push_back() 来完成的。
emplace()	在 queue 的尾部直接添加一个元素。
push(T&& obj)	==以移动的方式在 queue 的尾部添加元素。==这是通过调用底层容器的具有右值引用参数的成员函数 push_back() 来完成的。
pop()	删除 queue 中的第一个元素。
swap(queue &other_queue)	将两个 queue 容器适配器中的元素进行互换，需要注意的是，进行互换的 2 个 queue 容器适配器中存储的元素类型以及底层采用的基础容器类型，都必须相同。

和 stack 一样，queue 也没有迭代器，因此访问元素的唯一方式是遍历容器，通过不断移除访问过的元素，去访问下一个元素。

#include
#include
using namespace std;

int main(){
    deque<int> my_deque{1,2,3};
    queue<int> my_queue(my_deque);
    cout<<my_queue.size()<<endl;
    while(!my_queue.empty()){
        cout<<my_queue.front()<<endl;
        my_queue.pop();
    }
    return 0;
}

29. priority_queue容器适配器

priority_queue 容器适配器模拟的也是队列这种存储结构，但是，priority_queue 容器适配器中元素的存和取，遵循的并不是 “First in,First out”（先入先出）原则，先进队列的元素并不一定先出队列，而是优先级最大的元素最先出队列。

priority_queue 容器适配器为了保证每次从队头移除的都是当前优先级最高的元素，每当有新元素进入，它都会根据既定的排序规则找到优先级最高的元素，并将其移动到队列的队头；同样，当 priority_queue 从队头移除出一个元素之后，它也会再找到当前优先级最高的元素，并将其移动到队头。

//priority_queue定义
template <typename T, //指定存储元素的具体类型
        typename Container=std::vector<T>, //指定 priority_queue 底层使用的基础容器，默认使用 vector 容器
        typename Compare=std::less<T> > //指定容器中评定元素优先级所遵循的排序规则，默认使用std::less按照元素值从大到小进行排序，还可以使用std::greater按照元素值从小到大排序
class priority_queue{
    //......
}

1)创建

#include
using namespace std;
//创建空的适配器
priority_queue<int> p_queue;
//使用普通数组或其他容器中指定范围内的数据
int values1[]{4,2,3,1};
priority_queue<int> p_queue1(values1, values1+4); //{4,3,2,1}
std::array<int,4> values2{4,2,3,1};
priority_queue<int> p_queue2(values2.begin(), values2.end());
//手动指定使用的底层容器及排序规则
priority_queue<int, deque<int>, greater<int>> p_queue3(values1, values1+4);

2)成员函数

成员函数	功能
empty()	如果 priority_queue 为空的话，返回 true；反之，返回 false。
size()	返回 priority_queue 中存储元素的个数。
top()	返回 priority_queue 中第一个元素的引用形式。
push(const T& obj)	根据既定的排序规则，将元素 obj 的副本存储到 priority_queue 中适当的位置。
push(T&& obj)	根据既定的排序规则，将元素 obj 移动存储到 priority_queue 中适当的位置。
emplace(Args&&… args)	Args&&… args 表示构造一个存储类型的元素所需要的数据（对于类对象来说，可能需要多个数据构造出一个对象）。此函数的功能是根据既定的排序规则，在容器适配器适当的位置直接生成该新元素。
pop()	移除 priority_queue 容器适配器中第一个元素。
swap(priority_queue& other)	将两个 priority_queue 容器适配器中的元素进行互换，需要注意的是，进行互换的 2 个 priority_queue 容器适配器中存储的元素类型以及底层采用的基础容器类型，都必须相同。

和 queue 一样，priority_queue 也没有迭代器，因此访问元素的唯一方式是遍历容器，通过不断移除访问过的元素，去访问下一个元素。

30. priority_queue适配器实现自定义排序

当 头文件提供的排序方式（std::less 和 std::greater）不再适用时，需要自定义一个满足需求的排序规则

#include
#include
using namespace std;
//函数对象类
template <typename T>
class cmp{
public:
    //重载 () 运算符
    bool operator()(T a, T b){return a > b;}
};

int main(){
    int a[] = { 4,2,3,5,6 };
    priority_queue<int,vector<int>,cmp<int> > pq(a,a+5);
    while (!pq.empty()){
        cout << pq.top() << " ";
        pq.pop();
    }
    return 0;
}

#include
#include
using namespace std;
class node {
public:
    node(int x = 0, int y = 0) :x(x), y(y) {}
    int x, y;
    //以成员函数的方式重载
    //bool operator < (const node &b) const{
    //    if ((*this).x > b.x) return 1;
     //   else if ((*this).x == b.x)
     //       if ((*this).y >= b.y) return 1;
     //   return 0;
    //}
    //以友元函数的方式重载
    //friend bool operator <(const node& a, const node& b);
};

//通过重载 < 运算符，使得 std::less 变得适用
//新的排序规则为：先按照 x 值排序，如果 x 相等，则按 y 的值排序
bool operator < (const node &a, const node &b) {
    if (a.x > b.x) return 1;
    else if (a.x == b.x)
        if (a.y >= b.y) return 1;
    return 0;
}

int main() {
    //创建一个 priority_queue 容器适配器，其使用默认的 vector 基础容器以及 less 排序规则。
    priority_queue<node> pq;
    pq.push(node(1, 2));
    pq.push(node(2, 2));
    pq.push(node(3, 4));
    pq.push(node(3, 3));
    pq.push(node(2, 3));
    cout << "x y" << endl;
    while (!pq.empty()) {
        cout << pq.top().x << " " << pq.top().y << endl;
        pq.pop();
    }
    return 0;
}

总的来说，以函数对象的方式自定义 priority_queue 的排序规则，适用于任何情况；而以重载 > 或者 < 运算符间接实现 priority_queue 自定义排序的方式，仅适用于 priority_queue 中存储的是结构体变量或者类对象（包括 string 类对象）。

31. priority_queue容器的底层实现

priority_queue 优先级队列之所以总能保证优先级最高的元素位于队头，最重要的原因是其底层采用堆数据结构存储结构。priority_queue 底层采用 vector 或 deque 容器存储数据，这里又说使用堆结构存储数据，它们之间并不冲突。vector 和 deque 是用来存储元素的容器，而堆是一种数据结构，其本身无法存储数据，只能依附于某个存储介质，辅助其组织数据存储的先后次序。

堆是在完全二叉树的基础上，要求树中所有的父节点和子节点之间，都要满足既定的排序规则：

• 如果排序规则为从大到小排序，则表示堆的完全二叉树中，每个父节点的值都要不小于子节点的值，这种堆通常称为大顶堆
• 如果排序规则为从小到大排序，则表示堆的完全二叉树中，每个父节点的值都要不大于子节点的值，这种堆通常称为小顶堆

eg：{10,20,15,30,40,25,35,50,45}元素构成的大/小顶堆

STL 封装好了可以使用堆存储结构的方法，它们都位于 头文件中：

函数	功能
make_heap(first,last,comp)	选择位于 [first,last) 区域内的数据，并根据 comp 排序规则建立堆，其中 fist 和 last 可以是指针或者迭代器，默认是建立大顶堆。
push_heap(first,last,comp)	当向数组或容器中添加数据之后，此数据可能会破坏堆结构，该函数的功能是重建堆。
pop_heap(first,last,comp)	将位于序列头部的元素（优先级最高）移动序列尾部，并使[first,last-1] 区域内的元素满足堆存储结构。
sort_heap(first,last,comp)	对 [first,last) 区域内的元素进行堆排序，将其变成一个有序序列。
is_heap_until(first,last,comp)	发现[first,last)区域内的最大堆。
is_heap(first,last,comp)	检查 [first,last) 区域内的元素，是否为堆结构。

参考

1.http://c.biancheng.net/stl/