目录
1.什么是适配器?
我们之前实现栈和队列,都是我们自己去实现相应的功能,那么今天我们可以使用容器适配器来实现我们的栈和队列,那么什么是适配器呢?
我们日常生活中所见到的电源充电器,就是一种适配器,当我们使用的时候,会跟我们的插座相匹配,从而供我们使用。
2.栈(stack)
那么在栈和队列的实现中,我们该怎样使用相应的容器适配器呢?我们都知道,栈是一种后进先出的结构,它在一定程度上和我们的vector很相似,那么有什么办法可以用vector来模拟出一个栈呢?答案是可以的:
template<class T, class Container = vector<T>>
class stack
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_back();
}
T& top()
{
return _con[_con.size() - 1];
}
const T& top()const
{
return _con[_con.size() - 1];
}
bool empty()const
{
return _con.empty();
}
size_t size()const
{
return _con.size();
}
private:
Container _con;
};
这里在模板参数中,我们多了一个Container的模板参数,它的默认模板为vector模板,因为我们学习过vector和stack的使用, 因此用vector模拟一个stack还是非常简单的,本质上都是vector的调用,只不过我们在使用栈的时候,底层是vector而已。
3.队列(queue)
对于队列来说,我们要实现的是先进先出的结构,此时我们发现,vector是模拟实现不了queue的,所以我们想到了list:
template<class T, class Container = list<T>>
class queue
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
T& back()
{
return _con.back();
}
const T& back()const
{
return _con.back();
}
T& top()
{
return _con.front();
}
const T& top()const
{
return _con.front();
}
bool empty()const
{
return _con.empty();
}
size_t size()const
{
return _con.size();
}
private:
Container _con;
};
这里的使用还是调用的list的功能,对于queue来说先进先出即可,我们看起来使用的是queue,实际上是用list来模拟的。
4.双端队列(deque)
双端队列从名字就能看出来,它好像前后都可以快速插入和删除。实际上确实如此,双端队列类似vector和list的结合体,取精华去糟粕,它的底层是用指针数组来存储一小段连续的空间,但每个小段又是不连续的,因此它整体的空间其实是不连续的。相比于vector 和 list,deque的两端插入和删除效率都是不错的,但是其在中间插入的效率却很低。
它的使用与vector 和 list类似,这里我们看一下就知道该如何使用了,这里提到双端队列想要说的是,我们在模拟栈和队列的时候,可以把Container 默认都改为deque,因为栈和队列不涉及在中间段插入删除数据,只有在一端插入和删除,因此使用deque效率更优。
5.优先级队列(priority_queue)
优先级队列在插入和删除过程中需要满足一个优先级,优先级大的数据将被优先服务,这也就意味着当我们在插入和删除数据时,并不时按照队列那样先进先出的概念。
priority_queue的基础模拟实现:
template<class T, class Container = vector<int>, class Compare = less<T>>
class priority_queue
{
public:
private:
Container _con;
Compare com;
};
这里我们看到,我们的模板参数多了一个Compare = less<T> ,这是什么东西呢?那么我们就先来了解一下仿函数的概念:
1.什么是仿函数?
template<class T>
class less
{
public:
bool operator()(const T& v1, const T& v2)
{
return v1 < v2;
}
};
template<class T>
class greater
{
public:
bool operator()(const T& v1, const T& v2)
{
return v1 > v2;
}
};
仿函数本质上是一个类,它的使用就像是一个函数,它的里面必须要有operator() (括号)的重载,以上两个less 和 greater就是两个仿函数,里面有着判断数据大小的功能,也就是重载了() operator() 。
2.仿函数有什么用?
我们在使用库里面的sort函数的时候默认是升序,此时就可以使用仿函数来改变为降序:
这里就是仿函数的使用,它可以改变我们的比较方式,从而改变我们的排序是升序还是降序,来达到我们的使用要求。
3.优先级队列(priority_queue)
那么再来回头看看我们的优先级队列,我们已经说过,优先级队列在插入和删除的时候要遵循优先级大的先被服务,因此就少不了仿函数来随时的改变数据的优先级。
template<class T, class Container = vector<int>, class Compare = less<T>>
class priority_queue
{
public:
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last)
{
while (first != last)
{
_con.push_back(*first);
first++;
AdjustUp(_con.size() - 1);
}
}
void AdjustUp(size_t child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
if (com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
break;
}
}
void AdjustDown(int parent)
{
int child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
child++;
if (com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
void push(const T& x)
{
_con.push_back(x);
AdjustUp(_con.size() - 1);
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0);
}
T& top()
{
return _con[0];
}
const T& top()const
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
size_t size()
{
return _con.size();
}
private:
Container _con;
Compare com;
};
我们这里的优先级队列实质上是用vector容器来模拟了堆的实现,在push和pop(插入和删除)的时候使用了向上调整和向下调整,并且两种调整函数中的比较逻辑使用了仿函数,方便我们在使用的过程中修改优先级比较逻辑。
以上就是C++中栈、队列的基础知识,如有错误欢迎批评指正!