stack与queue
1. stack的模拟实现
- 我们这里模拟实现默认用vector来实现
namespace Stack
{
template <class T, class Container = deque<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:
Container _c;
};
}
2.queue的模拟实现
namespace Queue
{
template <class T, class Container = deque<T>>
class queue
{
public:
queue()
{}
void push(const T& x)
{
_c.push_back(x);
}
void pop()
{
_c.erase(_c.begin());
}
T& top()
{
return _c.front();
}
const T& top()const
{
return _c.front();
}
size_t size()const
{
return _c.size();
}
bool empty()const
{
return _c.empty();
}
private:
Container _c;
};
}
3. priority_queue的模拟实现
//自己实现的仿函数,仿函数就是一个类模版
template<class T>
class my_less
{
public:
bool operator()(const T& a, const T& b)
{
return a < b;
}
};
//自己实现的仿函数
template<class T>
class my_greater
{
public:
bool operator()(const T& a, const T& b)
{
return a > b;
}
};
namespace czy
{
template <class T, class Container = vector<T>, class Compare = my_less<T> >
class priority_queue
{
public:
void addjustdown(int parent)
{
int child = 2 * parent + 1;
while (child < c.size())
{
if (child + 1 < c.size() && comp(c[child], c[child+1]))
{
child++;
}
if (comp(c[parent], c[child]))
{
swap(c[parent], c[child]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
void addjustup(int child)
{
int parent = (child - 1) / 2;
while (child >= 0)
{
if (comp(c[parent], c[child]))
{
swap(c[parent], c[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
priority_queue()
{
}
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last)
{
while (first!=last)
{
push(*first);
++first;
}
}
bool empty() const
{
return c.empty();
}
size_t size() const
{
return c.size();
}
const T& top() const
{
return c.front();
}
void push(const T& x)
{
c.push_back(x);
addjustup(c.size()-1);
}
void pop()
{
swap(c[0], c[c.size() - 1]);
c.pop_back();
addjustdown(0);
}
private:
Container c;
Compare comp;
};
};
4. 容器适配器
4.1 适配器是什么
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设
计经验的总结),该种模式是将一个类的接口转换成客户希望的另外一个接口。
4.2 STL标准库中stack和queue的底层结构
我们在上面模拟实现的是一个用vector为适配器的下面来我们来看一下标准库中的实现
4. 3 deque的介绍
deque成员就是两个迭代器以及一个存放buffer数组地址的数组迭代器里面也有四个指针分别指向每个buffer的开头结束以及当前得位置和当前buffer的地址存放在中控器的那一个位置(通过node指针)。
4.4deque的缺陷
与vector比较,deque的优势是:头部插入和删除时,不需要搬移元素,效率特别高,而且在扩容时,也不需要搬移大量的元素,因此其效率是必vector高的。
与list比较,其底层是连续空间,空间利用率比较高,不需要存储额外字段。
但是,deque有一个致命缺陷:不适合遍历,因为在遍历时,deque的迭代器要频繁的去检测其是否移动到某段小空间的边界,导致效率低下,而序列式场景中,可能需要经常遍历,因此在实际中,需要线性结构时,大多数情况下优先考虑vector和list,deque的应用并不多,而目前能看到的一个应用就是,STL用其作为stack和queue的底层数据结构。
我们了解deque缺点之后我们来看看为什么stack,queue的底层数据结构是deque呢?
- stack,queue不支持迭代器因此就不用便利只需要插入删除刚好避开了deque的缺点
- 在stack中元素增长时,deque比vector的效率高(扩容时不需要搬移大量数据);queue中的元素增长时,deque不仅效率高,而且内存使用率高因为deque里面的buffer是连续的物理空间