一.适配器
stack和queue实际上并不能算是一种容器,而是一种容器适配器。而适配器作为stl的6大组件之一,其实是一种设计模式。适配器模式其实就是将一个类的接口(该接口无法直接满足客户的需求)转换成客户希望的另一个接口,以满足客户的需求。
而对于stack和queue来说,其就是借助另一个容器实现了LIFO(last in firtst out)和FIFO(first in first out)的功能。
而我们看到stack和queue的第二个模板参数容器给了缺省值,如果不指定容器,就会默认用deque来实现queue和stack。当然也可以利用其他的容器来实现,但是容器的结构一定得符合queue和stack的压入和弹出规则。
二.模拟实现stack
模拟实现stack时,必须要遵循stack的规则LIFO(last in first out)。而栈的接口只有压栈、出栈、取栈顶元素等操作,而我们用vector就可以完美实现stack的接口。
压栈直接调用vector的push_back即可,出栈调用vector的pop_back,取栈顶元素调用vector的back。
namespace xsc
{
template<typename T,typename Container = vector<T>>
class stack
{
public:
void push(const T& val)
{
_con.push_back(val);
}
void pop()
{
_con.pop_back();
}
T& top()
{
return _con.back();
}
bool empty()
{
return _con.empty();
}
int size()
{
return _con.size();
}
private:
Container _con;
};
}
但是当我们了解了list的结构之后,发现其也可以很好的实现stack的各种接口。所以我们使用栈时,既可以用缺省参数vector,也可以显式给出容器list。
xsc::stack<int> is;
xsc::stack<double, list<double>> is2;
三.模拟实现queue
模拟实现queue时,我们要了解其规则FIFO(first in first out).当我们要借助其他容器来实现queue时就不能再用vector来实现了。因为queue涉及到了删除队头的数据,vector并没有头删的接口,当然list和vector都有erase的接口,我们可以借助这个来实现,但是用vector会涉及到数据的挪动影响效率。所以我们默认采取list来实现queue。
queue的push借助list的push_back,pop借助list的pop_front,back、front分别借助list的back和front
namespace xsc
{
template<typename T,typename Container = list<T>>
class queue
{
public:
void push(const T& val)
{
_con.push_back(val);
}
void pop()
{
_con.pop_front();
}
T& front()
{
return _con.front();
}
T& back()
{
return _con.back();
}
bool empty()
{
return _con.empty();
}
int size()
{
return _con.size();
}
private:
Container _con;
};
}
四.deque
虽然我们借助list或者vector实现了stack和deque,但是我们看到标准库中栈和队列的容器参数默认是deque。那什么是deque呢?
deque实际是是一个双端队列,也是一个顺序容器,是一种双开口的"连续"空间的数据结构,双开口的含义是:可以在头尾两端 进行插入和删除操作,且时间复杂度为O(1),与vector比较,头插效率高,不需要搬移元素;与 list比较,空间利用率比较高。
我们可以看一下deque都实现了那些接口:
deque其实是vector和list的结合体。
因为vector和list都有其各自的优点和一些不足,所以设计容器的人就想是否可以设计出一个容器既包含vector的优点也包含list的优点——所有deque就问世了。
但是deque并没有达到预期,如果deque真的实现了vector和list优点的结合,那么vector和list就不会再用人用了。
1.vector和list的对比
vector的优点:
1、尾插尾删效率不错,支持高效下标随机访问
2、物理空间连续,所以高速缓存利用率高
vector的缺点:
1、空间需要扩容,扩容有一些代价(效率和空间浪费),且这个代价到后期数据多的时候更大
2、头部和中间插入/删除效率低(挪动数据)
list的优点:
1、按需申请释放空间,不需要扩容
2、支持任意位置O(1)的插入删除
list的缺点:
1、不支持下标的随机访问
2.deque的结构
deque的底层结构并不是一段连续的物理空间,而是类似于一个二维数组。由一个中控数组和若干个buff组成。
中控数组map其实是一个指针数组,其中存储着指向一个个buffer的指针。而buffer是一个定长数组(或者动态数组),所有的数据都存储在buffer上。
不同的是,中控数组map是从中间开始存储的,第一个buffer的指针存储在中控数组的中间部分,如果要头插就在该位置的前面存储一个buffer的地址。当map满了之后还需要对map进行扩容。
deque还重载了[] ,那么deque是如何支持下标访问的呢?
我们可以采取/和%的方式,定位到指定下标的元素位置。
假设要获取下标为i的元素,每一个buffer的大小为N。我们先用 x = i / N就可以得到该元素位于第几个buffer中;然后用y = i % N就可以知道该元素是这个buffer的第几个位置,然后借助两次operator[][]的调用map[x][y]就可以得到该数据。
3.deque的迭代器
deque的迭代器是由4个指针来实现的
cur指向当前正在访问的元素,first指向这段buffer的开始位置,last指向这段buffer的结束位置,node指向中控数组中存储这个buffer的位置。
借助这个迭代器,deque模拟出来物理空间连续的假象。
当我们遍历时,当cur等于last时说明这个buffer已经遍历完了,此时需要走到下一个buffer,只需要让node++即可。
4.deque的维护
deque这个容器的维护主要是借助两个迭代器来实现的:
这两个迭代器就相当于begin()和end()。分别指向开始和结尾。
遍历容器时,其实是创建一个迭代器,然后将start的值给他,然后通过cur来遍历。
5.deque的push_back()/push_front()
deque的尾插和头插效率都很高,尾插直接向buffer里面插入即可,如果buffer满了在申请一个即可。
deque的头插数据的方式有些许不同。头插时是往中控数组的的前面插入一个buffer,然后将头插的元素插入到buffer的尾部。
要注意的是头插和尾插之后start和finish都需要改变。
6.deque的insert/erase
当在中间位置插入删除时,有两种方式:
1、挪动数据,保证buffer的大小不变,但是这样就会导致效率极低
2、扩大或缩小buffer,但是这样会导致下标访问会更加困难,不能用/和%的方式得出下标位置。
总结:
1、deque的头尾插入删除效率很高,更甚于vector和list
2、下标随机访问也还不错,但略逊于vector
3、中间位置的插入删除效率很低O(N),需要挪动数据
7.deque的缺陷
与vector比较,deque的优势是:头部插入和删除时,不需要挪动数据,效率特别高,而且在扩容时,也不需要搬移大量数据,因此其效率是比vector高的。
与list比较,其底层空间是连续空间,空间利用率比较高,不需要存储额外字段
但是,deque有一个致命缺陷:不适合遍历,因为在遍历时,deque的迭代器需要频繁的去检查其是否移动到buffer的边界,导致效率低下,而在序列式场景中,可能需要经常遍历,因此在实际中,需要线性结构时,大多数情况下优先考虑vector和list,deque的应用并不多,而目前能看到的一个应用就是,STL用其作为stack和queue的底层数据结构
8.为什么选择deque作为stack和queue的底层默认容器
stack是一种后进先出的特殊线性数据结构,因此只要具有push_back()和pop_back()操作的线性结构,都可以作为stack的底层容器,比如vector和list;
queue是先进先出的特殊线性数据结构,只要具有push_back()和pop_front()操作的线性结构,都可以作为queue的底层容器,比如:list。
但是STL中对stack和queue默认选择deque作为其底层容器,主要是因为:
1、stack和queue不需要遍历(因此stack和queue没有迭代器),只需要在固定的一端或者两端进行操作
2、在stack中元素增长时,deque比vector的效率高(扩容时不需要搬移大量数据);queue中的元素增长时,deque不仅效率高,而且内存使用率还高。
结合了deque的优点,而完美的避开了其缺陷。
9.对比deque和vector的排序效率
我们从结果可以分析出,在存储相同数据的情况下,不论是直接比较deque和vector,还是用两个存储相同数据的deque,一个直接排序,一个先将数据拷贝到vector中,排序,拷贝会去,效率都是采用vector的高。
这是因为在sort算法下采用的是快排,快排需要对数据进行访问,而vector对数据的随机访问效率要比deque高得多。
void test_op1()
{
srand(time(0));
const int N = 1000000;
deque<int> dq;
vector<int> v;
for (int i = 0; i < N; ++i)
{
auto e = rand() + i;
v.push_back(e);
dq.push_back(e);
}
int begin1 = clock();
sort(v.begin(), v.end());
int end1 = clock();
int begin2 = clock();
sort(dq.begin(), dq.end());
int end2 = clock();
printf("vector:%d\n", end1 - begin1);
printf("deque:%d\n", end2 - begin2);
}
void test_op2()
{
srand(time(0));
const int N = 1000000;
deque<int> dq1;
deque<int> dq2;
for (int i = 0; i < N; ++i)
{
auto e = rand() + i;
dq1.push_back(e);
dq2.push_back(e);
}
int begin1 = clock();
sort(dq1.begin(), dq1.end());
int end1 = clock();
int begin2 = clock();
// 拷贝到vector
vector<int> v(dq2.begin(), dq2.end());
sort(v.begin(), v.end());
dq2.assign(v.begin(), v.end());
int end2 = clock();
printf("deque sort:%d\n", end1 - begin1);
printf("deque copy vector sort, copy back deque:%d\n", end2 - begin2);
}
五.priority_queue
1.priority_queue基本概念
priority_queue就是优先级队列,它也是一种容器适配器。但是它不同于queue,不再以deque作为底层容器,而是vector。
而priority_queue在底层是vector的前提下,又采用了堆的算法,将其包装成一个堆。所以priority_queue其实就是一个堆(默认是大堆)。其设计的一系列接口也都是模拟了堆的行为。
top取出堆顶的元素(最大/最小的元素)
push插入数据然后采用向上调整算法使其依旧是一个堆
pop删除堆顶的数据然后采用向下调整算法使其依旧是一个堆
在使用向上(向下)调整算法时,要保证其原本就是堆。
小伙饿坏了,赶紧点了一份爱学的二叉树——堆,狼吞虎咽学完很过瘾-CSDN博客
在这里可以回顾一下堆的基本操作:
1、堆是一个完全二叉树,完全二叉树就是前面每层都是满的,最后一层从左到右是连续的。
2、知道一个父亲节点的下标parent,怎么求它的左右孩子:left = 2*parent+1,right = 2*parent+2
3、知道孩子节点的下标child,怎么求父亲节点:parent = (child-1)/2.
4、大堆:父亲节点的值大于等于左右孩子的值,但左右孩子之间没有大小关系
5、小堆:父亲节点的值小于等于左右孩子的值,但左右孩子之前没有大小关系。
6.插入节点:插入节点是插入到最后一层从左到右的最后一个位置,但是插入必须要保证插入之后也是一个堆,所以插入之后要进行向上调整,与它的父亲节点比较,如果是大堆的话,插入的大于父亲节点就交换,直到小于某个父亲节点或者到达堆顶就停止交换。
7.删除堆顶元素:首先将堆顶元素与最后一个节点交换,然后再删除最后一个节点,然后进行向下调整,使之仍然是堆
优先级队列之所以默认是大堆,原因在于其第三个模板参数 ,当我们改变第三个模板参数时,就可以将其变为小堆
//priority_queue<int> q; // 大堆
priority_queue<int,vector<int>,greater<int>> q; // 小堆
2.模拟实现priority_queue
默认是大堆
插入之后向上调整时,将孩子与父亲进行比较,如果孩子大于父亲就交换,直到孩子小于父亲/已经交换到了堆顶。
删除之后向下调整时,父亲与左右孩子大的那个交换(采取假设法:先假设左孩子大,再判断右孩子是否大于左孩子,如果大于那么child+1),直到父亲大于左右孩子,或者已经交换到最后一层。
小伙饿坏了,赶紧点了一份爱学的二叉树——堆,狼吞虎咽学完很过瘾-CSDN博客
namespace xsc
{
//默认是大堆
template <typename T, typename Container = vector<T>>
class priority_queue
{
public:
void AdjustUp(int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (_con[child] > _con[parent])
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& val)
{
_con.push_back(val);
AdjustUp(_con.size() - 1);
}
void AdjustDown(int parent)
{
int child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && _con[child] < _con[child + 1])//只有这个条件可能会越界:a[child] > a[child + 1]
{
child += 1;
}
if (_con[parent] < _con[child])
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0);
}
T& top()
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
int size()
{
return _con.size();
}
private:
Container _con;
};
}
那如果要实现一个小堆呢?难道要写出两个类模板么?
在标准库中的priority_queue是借助第三个模板参数来实现的:
//priority_queue<int> q; // 大堆
//priority_queue<int, vector<int>, less<int>>;// 第三个默认参数是less<int>
priority_queue<int,vector<int>,greater<int>> q; // 小堆
而这第三个模板参数其实是借助仿函数来实现的。
3.仿函数
仿函数人如其名,它并不是一个函数,而是一个重载了()的一个类或者结构体,它可以使其看上去像一个函数一样,像函数一样使用。仿函数可以接受参数并返回值,可以用于STL算法中的函数对象参数,也可以用于函数指针的替代。
template <typename T>
struct Less
{
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
int main()
{
Less<int> l;
cout << l(1, 2) << endl;
return 0;
}
我们实际上是借助这个类创建了一个对象,但是我们使用这个对象的方式却是调用函数的行为,这就是仿函数。
实际上是调用了该类的operator()。
cout << l.operator(1, 2) << endl;
我们可以实现两个仿函数Less和Greater来封装比较的逻辑,对priority_queue增加第三个模板参数,并将其内部的比较都换成仿函数的比较方式,以此来改变向上向下调整的比较逻辑,实现大堆/小堆。
在库中,less默认是<,gerater默认是>,所以我们采取和库里一样的比较方式。
template <typename T>
struct Less
{
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template <typename T>
struct Greater
{
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
用第三个模板参数创建一个对象,然后用该对象调用operator(),进行比较。注意在比较时要注意符合符号以及是大堆还是小堆。
完!