1.stack和queue
stack和queue的相关接口如下:
stack
queue
我们发现不管是stack还是queue,它们都有push和pop,不区分push_back和push_front,这是由它们的入栈特定顺序特性决定的,并且它们都没有迭代器,stack只有top,queue只有front和back这使得我们只能以规定的方式去访问这个stack或者queue
emplace相当于入栈,一般我们用push就可以了。
2.stack和queue的模拟实现
我们已经知道stack、queue和vector、list本质上并没有区别,所以我们可以将复用的思想带到它们的实现中,并且我们可以利用模板对于同一个stack模板,使用不同的底层来实现。这体现了继迭代器模式后的第二种设计模式:适配器模式,即转换。
下面是它们的实现
cpp
template<class T, class Container = vector<T>>
class stack
{
public:
stack(const Container& con = Container())
:_con(con)
{}
void push(const T& val)
{
_con.push_back(val);
}
void pop()
{
_con.pop_back();
}
T& top()
{
return _con.back();
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.empty();
}
void swap(stack& st)
{
std::swap(_con, st._con);
}
private:
Container _con;
};
template<class T, class Container = list<T>>
class queue
{
public:
queue(const Container& con = Container())
:_con(con)
{}
void push(const T& val)
{
_con.push_back(val);
}
void pop()
{
_con.pop_front();
}
T& back()
{
return _con.back();
}
T& front()
{
return _con.front();
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.empty();
}
void swap(queue& q)
{
std::swap(_con, q._con);
}
我们可以看出,stack和queue的实现几乎不需要自己实现具体功能,我们只需要关注上层功能而不是底层的细节,这极大地体现了封装的特性。
代码中仍有一些细节点需要注意:
(1)为什么只写了构造但没有写析构?为什么构造有缺省值
构造时我们可能空构造,需要缺省值,也有可能带参构造,带参构造需要我们形参接收,这里展示的是拷贝构造的情况,析构的时候成员_con作为自定义类型会去调用自己的析构函数,不会存在内存泄露的情况,所以不需要我们显式的去写析构
(2)swap为什么使用std::swap?
事实上,当我们包含了<vector><list>后,std域里的swap函数就多了几个重载,这几个重载是专门针对vector和list类型的,_con和q._con是Container类型,也就是vector<int>或list<int>类型,会去调用重载的效率较高的swap函数。
之所以std里重载swap函数,就是为了让我们在不知vector类里有swap成员函数的情况下也能高效地交换(只交换指针的值而不是交换所有指向的值)。因此除了这种写法,我们还可以显式调用vector类的成员函数
(3)stack只能以vector作为容器吗?
**vector是连续的物理结构,下标访问快,但头插效率极低。因此vector不支持头插头删。**在queue中pop使用了pop.front(),在vector里没有这个接口,所以不能使用vector实现queue,但是我们如果用erase来实现pop也可以,这样就可以用vector实现queue了,但并不建议这么做,因为vector实现queue本就是效率极低的做法。
**list是分散的物理结构,任意位置插入删除效果都不错,但下标访问效率低。因此list不支持下标访问。**但是stack和queue都没用到下标访问,因此我们可以用list实现queue和stack。
事实上,stack和queue在STL中都是以deque作为默认的容器。我们发现,vector和list本就是两个极端的存储结构。所以deque是结合vector、list,能同时进行下标访问和push_back、push_front等操作的容器。
**deque用buff小数组+中控数组来实现它的功能,是vector和list存储的结合体,虽然支持下标访问,但它的没vector快,deque[]偶尔用用还行,头尾删除不错。**我们适当了解一下deque即可,不用深究,因为deque本不算一个效率高的容器。
3.优先级队列和仿函数
priority_queue本质上是堆,我们只要掌握了堆,优先级队列的核心就能很快完成了。
但是priority_queue用到了仿函数的知识点,在大堆小堆的处理和我们C语言有所不同
(1)仿函数:
仿函数,即模仿函数的一个类,我们看下面的代码:
**comp(1,2)是我们常见的函数的写法,但它的本质是是一个类重载了operator()后表现出来的类似于函数的特性。**仿函数实现起来也相当简单,只要理解了它的实质就能很快上手
但是仿函数和构造函数容易搞混,一定要注意仿函数是要针对已创建的对象调用而不是针对类来调用,那种写法是构造函数而不是仿函数
(2)优先级队列
优先级队列的功能很简单,就是结合vector、仿函数实现堆,核心代码就是AdjustUp和AdjustDown。
建议将AdjustUp和AdjustDown放进private,对外只提供push、pop这样的接口,体现封装的特性。
注意当仿函数是less时默认是大堆,greater默认是小堆,在我们进行数值比较时要注意谁在前谁在后,因为顺序不同,会影响返回值,从而影响我们生成的堆的类型。
由于堆相关的知识前面我已经详细讲过,这里就不多阐述了。
完整代码如下:
cpp
namespace my_priority_queue
{
template<typename T>
class less
{
public:
bool operator()(const T& t1, const T& t2)
{
return t1 < t2;
}
};
template<typename T>
class greater
{
public:
bool operator()(const T& t1, const T& t2)
{
return t1 > t2;
}
};
template<typename T, class Container = vector<T>, class Compare = less<T>>
class priority_queue
{
public:
priority_queue() = default;
template<typename iterator>
priority_queue(iterator begin, iterator end)
{
while (begin != end)
{
_con.push_back(*begin);
begin++;
}
for (int parent = (int)(size() - 2) / 2; parent >= 0; parent--)
{
AdjustDown(parent);
}
}
size_t size()
{
return _con.size();
}
void push(const T& val)
{
_con.push_back(val);
AdjustUp(size() - 1);
}
void pop()
{
std::swap(_con[0], _con[size() - 1]);
_con.pop_back();
AdjustDown(0);
}
const T& top()
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
void swap(priority_queue& p)
{
std::swap(_con, p._con);
}
private:
void AdjustUp(size_t child)
{
Compare comp;
size_t parent = (child - 1) / 2;
while (child > 0)
{
if (comp(_con[parent], _con[child]))
std::swap(_con[parent], _con[child]);
child = parent;
parent = (child - 1) / 2;
}
}
void AdjustDown(size_t parent)
{
Compare comp;
size_t child = parent * 2 + 1;
while (child < size())
{
if (child + 1 < size() && comp(_con[child], _con[child + 1]))
child++;
if(comp(_con[parent], _con[child]))
std::swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
}
private:
Container _con;
};
}