文章目录
其实学了前面三个结构再来看这两个就有点小菜一碟的感受了,其本质无非和我们之前用c语言实现时一样,那么下面我们就带大家用c++实现一下,然后再来讲讲其中的一些用法和区别吧
容器适配器
首先在正式开始之前,我们要介绍一下这个容器适配器的概念。
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总
结),该种模式是将一个类的接口转换成客户希望的另外一个接口。
就好比充电线的接口之间的相互转换一样,我们用不同的接口来达到最后可以满足设备充电的需求。
而我们今天的主角stack和queue它们并没有被划分在容器的行列,而是被称为容器适配器。
1.Stack
1.介绍
这副图片其实就很形象的表明了stack的基本结构和操作,其最突出的特点就是数据的先入后出
2.基本操作
函数说明 | 接口说明 |
---|---|
stack() | 构造空的栈 |
empty() | 检测stack是否为空 |
size() | 返回stack中元素的个数 |
top() | 返回栈顶元素的引用 |
push() | 将元素val压stack中 |
pop() | 将stack中尾部的元素弹出 |
3.模拟实现
#include<vector>
namespace myself
{
template<class T>
class stack
{
public:
stack() {}
void push(const T& x) {_c.push_back(x);}
void pop() {_c.pop_back();}
T& top() {return _c.back();}
const T& top()const {return _c.back();}
size_t size()const {return _c.size();}
bool empty()const {return _c.empty();}
private:
std::vector<T> _c;
};
}
这里的实现我们是套用了一层vector,当然在默认情况下套用的容器应该是deque,这个容器我们在之后会有介绍。
2.Queue
1.介绍
这样的一幅图想必也能帮助大家很快回忆起它最鲜明的特点了——数据先进先出。
正如上述所说的一样这也是一种适配器,而且同样底层默认用的是deque。
2.基本操作
函数说明 | 接口说明 |
---|---|
queue() | 构造空的队列 |
empty() | 检测queue是否为空 |
size() | 返回queue中元素的个数 |
front() | 返回队头元素的引用 |
back() | 返回队尾元素的引用 |
push() | 在队尾将元素val入队列 |
pop() | 将队头元素出队列 |
3.模拟实现
因为queue的接口中存在头删和尾插,因此使用vector来封装效率太低,所以我们这里借助list来模拟实现queue
#include <list>
namespace bite
{
template<class T>
class queue
{
public:
queue() {}
void push(const T& x) {_c.push_back(x);}
void pop() {_c.pop_front();}
T& back() {return _c.back();}
const T& back()const {return _c.back();}
T& front() {return _c.front();}
const T& front()const {return _c.front();}
size_t size()const {return _c.size();}
bool empty()const {return _c.empty();}
private:
std::list<T> _c;
};
}
3.priority_queue
1.介绍
优先队列也是一种适配器,它的第一个元素总是所有包含元素中最大的,这种结构有点类似于我们之前学的大堆
一般默认没有说明的情况下,其底层用的容器为vector
**重点:**因为要支持堆的结构,所以它的支持随机访问迭代器的使用,容器适配器通过在需要时自动调用算法函数
make_heap、push_heap和pop_heap来自动完成此操作。
2.使用
函数声明 | 接口说明 |
---|---|
priority_queue()/priority_queue(fifirst,last) | 构造一个空的优先级队列 |
empty( ) | 检测优先级队列是否为空,是返回true,否则返回false |
top( ) | 返回优先级队列中最大(最小元素),即堆顶元素 |
push(x) | 在优先级队列中插入元素x |
pop() | 删除优先级队列中最大(最小)元素,即堆顶元素 |
实际使用案例的演示
#include <vector>
#include <queue>
#include <functional> // greater算法的头文件
void TestPriorityQueue()
{
// 默认情况下,创建的是大堆,其底层按照小于号比较
vector<int> v{3,2,7,6,0,4,1,9,8,5};
priority_queue<int> q1;
for (auto& e : v)
q1.push(e);
cout << q1.top() << endl;
// 如果要创建小堆,将第三个模板参数换成greater比较方式
priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());
cout << q2.top() << endl; }
}
3.模拟实现
实际上就是封装一层vector,然后写个大小堆的构建,这里就不一一赘述了,直接上代码
#pragma once
#include <iostream>
using namespace std;
#include <vector>
// priority_queue--->堆
namespace myself
{
template<class T>
struct less
{
bool operator()(const T& left, const T& right)
{
return left < right;
}
};
template<class T>
struct greater
{
bool operator()(const T& left, const T& right)
{
return left > right;
}
};
template<class T, class Container = std::vector<T>, class Compare = less<T>>
class priority_queue
{
public:
// 创造空的优先级队列
priority_queue() : c() {}
template<class Iterator>
priority_queue(Iterator first, Iterator last)
: c(first, last)
{
// 将c中的元素调整成堆的结构
int count = c.size();
int root = ((count - 2) >> 1);
for (; root >= 0; root--)
AdjustDown(root);
}
void push(const T& data)
{
c.push_back(data);
AdjustUP(c.size() - 1);
}
void pop()
{
if (empty())
return;
swap(c.front(), c.back());
c.pop_back();
AdjustDown(0);
}
size_t size()const
{
return c.size();
}
bool empty()const
{
return c.empty();
}
// 堆顶元素不允许修改,因为:堆顶元素修改可以会破坏堆的特性
const T& top()const
{
return c.front();
}
private:
// 向上调整
void AdjustUP(int child)
{
int parent = ((child - 1) >> 1);
while (child)
{
if (Compare()(c[parent], c[child]))
{
swap(c[child], c[parent]);
child = parent;
parent = ((child - 1) >> 1);
}
else
{
return;
}
}
}
// 向下调整
void AdjustDown(int parent)
{
size_t child = parent * 2 + 1;
while (child < c.size())
{
// 找以parent为根的较大的孩子
if (child + 1 < c.size() && Compare()(c[child], c[child + 1]))
child += 1;
// 检测双亲是否满足情况
if (Compare()(c[parent], c[child]))
{
swap(c[child], c[parent]);
parent = child;
child = parent * 2 + 1;
}
else
return;
}
}
private:
Container c;
};
}
4.deque
1.介绍
deque(双端队列):是一种双开口的"连续"空间的数据结构
可以在头尾两端进行插入和删除操作,且时间复杂度为O(1),与vector比较,头插效率高,不需要搬移元素;与list比较,空间利用率比较高。
这个图非常形象,但是实际上deque并非是一块连续开辟的空间,事实上它由上图这么一个个连续开辟的小空间所组成的一个整体。
看了这第二幅图片就明确多了,其基本结构实际上就如上图所示
2.优缺点分析
与vector比较,deque的优势是:头部插入和删除时,不需要搬移元素,效率特别高,而且在扩容时,也不
需要搬移大量的元素,因此其效率是必vector高的。
与list比较,其底层是连续空间,空间利用率比较高,不需要存储额外字段。
但是,deque有一个致命缺陷:不适合遍历,因为在遍历时,deque的迭代器要频繁的去检测其是否移动到
某段小空间的边界,导致效率低下,而序列式场景中,可能需要经常遍历,因此在实际中,需要线性结构
时,大多数情况下优先考虑vector和list,deque的应用并不多,而目前能看到的一个应用就是,STL用其作
为stack和queue的底层数据结构。