C++——stack_queue
1.stack的介绍和使用
1.1stack的介绍
a.stack是一种容器适配器，专门用在具有先进后出操作的上下文环境中，其删除只能从容器的一段进行元素的插入与提取操作。
b.stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部被压入和弹出。
c.stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作。
empty:判空操作
back:获取尾部元素操作
size:返回有效元素的个数
push_back:尾部插入操作
pop_back:尾部删除操作
d.标准容器vector、list、deque符合这些要求，默认情况下，如果没有stack指定特定的底层容器，默认情况下使用deque。
1.2stack的使用
int main()
{
stack<int> st;
st.push(1); //入栈
st.push(2);
st.push(3);
st.push(4);
st.push(5);
st.pop(); //出栈
cout << st.empty() << endl; //判断栈是否为空
cout << st.size() << endl; //获取栈中有效元素个数
cout << st.top() << endl; //获取栈顶元素
return 0;
}1.3stack的模拟实现
namespace Stack
{
template<class T, class Container = std::vector<int>>
class stack
{
public:
bool empty() { return _st.empty(); }
void pop() { _st.pop_back(); }
void push(T a) { _st.push_back(a); }
int size() { return _st.size(); }
T top() { return _st.back(); }
private:
Container _st;
};
void stack_test()
{
stack<int, vector<int>> st;
st.push(1);
st.push(2);
st.push(3);
st.pop();
cout << st.empty() << endl;
cout << st.size() << endl;
cout << st.top() << endl;
}
}2.queue的介绍和使用
2.1queue的介绍
a.队列是一种容器适配器，专门用于在FIFO上下文中操作，其中从容器一端插入元素，另一端提取元素。
b.队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从对尾入队列，从队头出队列。
c.底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类，该底层容器应至少支持以下操作。
empty:判空操作
back:获取尾部元素操作
front:获取头部元素操作
size:返回有效元素的个数
push_back:尾部插入操作
pop_front:头部删除操作
d.标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。
2.2queue的使用
int main()
{
queue<int> q;
q.push(1); //入队
q.push(2);
q.push(3);
q.pop(); //出队
cout << q.empty() << endl; //判断队列是否为空
cout << q.size() << endl; //获取队列中有效元素个数
cout << q.front() << endl; //获取队头元素
cout << q.back() << endl; //获取队尾元素
return 0;
}2.3queue的模拟实现
namespace Queue
{
template<class T, class Container = std::list<int>>
class queue
{
public:
bool empty() { return _q.empty(); }
void pop() { _q.pop_front(); }
void push(T a) { _q.push_back(a); }
int size() { return _q.size(); }
T back() { return _q.back(); }
T front() { return _q.front(); }
private:
Container _q;
};
void queue_test()
{
queue<int, list<int>> q;
q.push(1);
q.push(2);
q.push(3);
q.pop();
cout << q.empty() << endl;
cout << q.size() << endl;
cout << q.front() << endl;
cout << q.back() << endl;
}
}3priority_queue的介绍和使用
3.1priority_queue的介绍
a.优先级队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
b.此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素。
c.优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
d.底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类，容器应该可以通过随机访问迭代器访问，并支持一下操作。
empty:判空操作
front:获取头部元素操作
size:返回有效元素的个数
push_back:尾部插入操作
pop_back:尾部删除操作
e.标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
f.需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。
3.2priority_queue的使用
优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。默认情况下priority_queue是大堆。
int main()
{
vector<int> v{ 2,5,9,7,5,7,9,6 };
priority_queue<int> pq;
for (auto& e : v)
{
pq.push(e); //插入元素
}
pq.pop(); //删除队列中最大元素，即堆顶元素
cout << pq.empty() << endl; //检测是否为空
cout << pq.top() << endl; //返回队列中最大元素，即堆顶元素
return 0;
}3.3仿函数
仿函数就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数了。
如果要创建小堆，需要用到仿函数，将第三个模板参数替换成为greater比较方式。
namespace func
{
//less仿函数
template<class T>
struct less
{
bool operator()(const T& left, const T& right)
{
return left < right;
}
};
//greater仿函数
template<class T>
struct greater
{
bool operator()(const T& left, const T& right)
{
return left > right;
}
};
}
int main()
{
vector<int> v{ 2,5,9,7,5,7,9,6 };
priority_queue<int, vector<int>, func::greater<int>> pq;
for (auto& e : v)
{
pq.push(e);
}
pq.pop();
cout << pq.empty() << endl;
cout << pq.top() << endl;
return 0;
}3.4priority_queue的模拟实现
namespace Priority_queue
{
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<int>, class Compare = less<T>>
class priority_queue
{
public:
void AdjustUp(int child)
{
Compare com;
int parent = (child - 1) / 2;
while (child > 0)
{
if (com(_pq[parent], _pq[child]))
{
swap(_pq[parent], _pq[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void AdjustDwon(int parent)
{
Compare com;
size_t child = parent * 2 + 1;
while (child < _pq.size())
{
if (child + 1 < _pq.size() && com(_pq[child], _pq[child + 1]))
{
++child;
}
if (com(_pq[parent], _pq[child]))
{
swap(_pq[parent], _pq[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
bool empty() const { return _pq.empty(); }
size_t size() const { return _pq.size(); }
T top() const { return _pq[0]; }
void push(const T& x)
{
_pq.push_back(x);
AdjustUp(_pq.size() - 1);
}
void pop()
{
swap(_pq[0], _pq[_pq.size() - 1]);
_pq.pop_back();
AdjustDwon(0);
}
private:
Container _pq;
};
}4.容器适配器
4.1什么是容器适配器
适配器是一种设计模式（设计模式是一套被反复使用的，多数人知晓的，经过分类编目的、代码设计经验的总结），该种模式是将一个类的接口转换成客户希望的另外一个接口。
stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和queue只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque。
4.2deque的简单了解
4.2.1duque的原理介绍
deque（双端队列）：是一种双开口的“连续”空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要移动元素；与list比较，空间利用率比较高。
deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所述：
双端队列底层是一段假象的连续空间，实际是分段的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器上，因此deque的迭代器设计比较复杂，如下图所示：
4.2.2duque的缺陷
与vector相比，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此效率是比vector高的。
与list相比，其底层是连续空间，空间利用率高，不需要存储额外字段。
但是duque有一个致命缺陷：不适合遍历，因为在遍历时，duque的迭代器要频繁的去检测是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要选型结构时，大数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。
4.3为什么选择duque作为stack和queue的底层默认容器
1.stack和queue不需要遍历，只需要在固定的一端或者两端进行操作。
2.在stack中元素增长时，deque比vector的效率高；queue中的元素增长时，duque不仅效率高，而且内存使用率高。
6896
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
