stack 的实现
1.特征：先进后出 。只能插入，删除，访问栈顶的元素 ！！
2.实现
可以用 vector ,list ,deque 来实现。但是 vector和deque 的实现要比list实现的性能好
#include<iostream>
#include<deque>
using namespace std;
template<class T ,class cont = deque<T> > //类模板
class stack{
cont tt ;
public:
T & top(){
return tt.front();
}
void pop( ){
tt.pop_front() ;
}
void push(T temp){
tt.push_front(temp);
}
int size(){
return tt.size();
}
};
int main(void)
{
stack<int> st ;
st.push(1);
st.pop();
st.push(2);
st.push(3);
st.pop();
cout << "1,st.top() == " << st.top() << endl ;
st.push(4);
cout << "2,st.top() == " << st.top() << endl ;
cout << "3,st.size() == " << st.size() << endl ;
return 0;
}运行截图：
queue 的实现
1.特征：先进先出 。只能操作队头与队尾的元素 ！！
2.实现
可以用 list和deque 来实现 。
#include<iostream>
#include<deque>
using namespace std;
template<class T ,class cont = deque<T> > //类模板
class queue{
cont tt ;
public:
T & top(){
return tt.front();
}
T & back(){
return tt.back();
}
void pop( ){
tt.pop_front() ;
}
void push(T temp){
tt.push_back(temp);
}
int size(){
return tt.size();
}
};
int main(void)
{
queue<int> que ;
que.push(1);
que.push(2);
que.push(3);
que.pop();
cout << "1,que.top() == " << que.top() << endl ;
cout << "2,que.back() == " << que.back() << endl ;
que.push(4);
cout << "3,que.top() == " << que.top() << endl ;
cout << "4,que.back() == " << que.back() << endl ;
cout << "5,que.size() == " << que.size() << endl ;
return 0;
}运行截图：
priority_queue 的实现
1.特征：与queue 类似 ，只不过根据优先级时时刻刻在调整队中的元素顺序(所采用的排序方法是:堆排序),队头始终是“最大”的元素 ，但不保证整个队列始终有序 ，非常适合贪心算法的实现。
2.实现
可以用 vector 和 deque 来实现 。
默认的元素比较器是 less
/*********************************************
我的具体实现：
1.使用 vector 来实现
2.自写堆排序 ，因此就直接采用通常意义上的大与小的关系了
3. 采用模板实现优先队列
*********************************************/
#include<iostream>
#include<vector>
using namespace std;
class HEAP { //实现堆排序
public :
void HeapAdjust(vector<double> &vec, double parent, double size) {
double temp = vec[parent]; // temp保存当前父节点
double child = 2 * parent + 1; // 先获得左孩子
while (child < size ){
// 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
if (child + 1 < size && vec[child] < vec[child + 1]) {
child++;
}
// 如果父结点的值已经大于孩子结点的值，则直接结束
if (temp >= vec[child])
break;
// 把孩子结点的值赋给父结点
vec[parent] = vec[child];
// 选取孩子结点的左孩子结点,继续向下筛选
parent = child;
child = 2 * child + 1;
}
vec[parent] = temp;
}
void heapSort(vector<double> &list) {
// 循环建立初始堆
for (double i = list.size() / 2; i >= 0; i--) {
HeapAdjust(list, i, list.size());
}
// 进行n-1次循环，完成排序
for (double i = list.size() - 1; i > 0; i--) {
// 最后一个元素和第一元素进行交换
double temp = list[i];
list[i] = list[0];
list[0] = temp;
// 筛选 R[0] 结点，得到i-1个结点的堆
HeapAdjust(list, 0, i);
}
}
};
template<class T ,class cont = vector<T> > // 用 vector 来实现
class priority_queue{
cont tt ;
HEAP heap ;
public:
T & top(){
heap.heapSort(tt);
return tt[0];
}
void pop(){ //先按照规则排序，然后移动其余所有元素 ，最后pop_back()
heap.heapSort(tt);
for(int i= 0 ;i< tt.size() ;++i){
tt[i] = tt[i+1];
}
tt.pop_back();
}
void push(T temp){
tt.push_back(temp);
}
int size(){
return tt.size();
}
};
int main(void)
{
priority_queue<double> priority_que ;
priority_que.push(88.2);
priority_que.push(56.5);
priority_que.push(99.6);
priority_que.pop();
cout << "1,priority_que.top() == " << priority_que.top() << endl ;
priority_que.push(44);
cout << "2,priority_que.top() == " << priority_que.top() << endl ;
cout << "3,priority_que.size() == " << priority_que.size() << endl ;
return 0;
}运行截图：
附加：priority_queue 自定义优先级比较顺序
#include<iostream>
#include<queue>
using namespace std;
struct A {
A (double _n):tt(_n) {}
double tt ;
friend bool operator < (const A &a ,const A &b){
return a.tt > b.tt ; //反着 “<” 来
}
};
int main(void)
{
priority_queue<A> priority_que ;
priority_que.push(A(88.2));
priority_que.push(A(56.5)) ;
priority_que.push(A(99.6));
priority_que.pop();
cout << "1,priority_que.top() == " << priority_que.top().tt << endl ;
priority_que.push(A(44));
cout << "2,priority_que.top() == " << priority_que.top().tt << endl ;
cout << "3,priority_que.size() == " << priority_que.size() << endl ;
return 0;
}运行截图：
