Stack与Queue的实现（c++模板实现）

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;
}

运行截图：

关于附加的一点说明：因为我也是刚接触优先队列这东西，所以这种写法只能说能用，我也不太清楚是不是最常用的或者说是最标准的 ，希望在有些方面不要误导读者 ，同时也希望读者能够提出宝贵的意见 ，共同交流进步！