c++stack&queue

stack模拟实现：

#pragma once
#include<deque>
#include<vector>
#include<stack>
#include<iostream>
using namespace std;
namespace my_stack
{
    template<class T,class Container>
    class stack
    {
    public:
        stack()
        {

        }
        
        void push(T&val)
        {
            _con.push_back(val);
        }

        void pop()
        {
            _con.pop_back();
        }

        T& top()
        {
            return _con.back();
        }
         

        bool empty()const
        {
            return _con.empty();
        }

        size_t size()const
        {
            return _con.size();
        }


    private:
        Container _con;
    };


    void test_mystack()
    {
        stack<int,vector<int>> st;

    }
}

queue模拟实现：

#pragma once
#include<deque>
#include<list>
#include<iostream>
using namespace std;


namespace my_queue
{
    template<class T,class Container=deque<T>>
    class queue
    {
    public:
        queue()
        {}

        void push(const T& val)
        {
            _con.push_back(val);
        }

        void pop()
        {
            _con.pop_front();
        }

        T& back()
        {
            return _con.back();
        }

        T& front()
        {
            return _con.front();
        }


        const T& back()const
        {
            return _con.back();
        }

        const T& front()const
        {
            return _con.front();
        }
        bool empty()
        {
            return _con.empty();
        }
        size_t size()
        {
            return _con.size();
        }

    private:
        Container _con;

    };

    void test_queue()
    {
        queue<int, list<int>> q1;
        q1.push(1);
        q1.push(2);
        q1.push(3);
        q1.push(4);
        q1.push(5);
        while (!q1.empty())
        {
            cout << q1.front() << endl;
            q1.pop();
        }

    }
}

priority_queue模拟实现：

#pragma once
#include<vector>
#include<iostream>
using namespace std;

namespace my_priority_queue
{
    template<class T,class Container=vector<T>>
    class priority_queue
    {
    public:
        template<class IputeIterator>
        priority_queue(IputeIterator first, IputeIterator last)
        {
            while (first != last)
            {
                _con.push_back(*first);
                ++first;
            }
            for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
            {
                adjust_down(i);
            }
        }

        priority_queue()
        {

        }

        size_t size()
        {
            return _con.size();
        }

        void adjust_up(int child)
        {
            int parent = (child - 1) / 2;
            while (child > 0)
            {
                if (_con[child] > _con[parent])
                {
                    std::swap(_con[child], _con[parent]);
                    child = parent;
                    parent = (child - 1) / 2;
                }
                else
                {
                    break;
                }
            }
        }
        T& top()
        {
            return _con.front();
        }

        void push(const T& val)
        {
            _con.push_back(val);
            adjust_up(_con.size() - 1);
        }

        void adjust_down(int parent)
        {
            int child = parent * 2 + 1;
            while (child < _con.size())
            {
                if (child+1<_con.size()&&_con[child] < _con[child + 1])
                {
                    child += 1;
                }
                if (_con[child] > _con[parent])
                {
                    std::swap(_con[child], _con[parent]);
                    parent = child;
                    child = parent * 2 + 1;
                }
                else
                {
                    break;
                }

            }
            
        }

        void pop()
        {
            std::swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();
            adjust_down(0);
        }

        ~priority_queue()
        {

        }

        bool empty()
        {
            return _con.empty();
        }

    private:
        Container _con;
    };

    void test_priority_queue()
    {
        int arry[] = { 1,2,3,4,5,6,7,8,9,0 };
        priority_queue<int>ls;
        priority_queue<int>ls1(arry, arry+10);

        ls.push(1);
        ls.push(2);
        ls.push(3);
        ls.push(4);
        ls.push(5);

        while (!ls1.empty())
        {
            cout << ls1.top() << endl;
            ls1.pop();
        }
    }

}

上面的函数大体上实现了库中的优先级队列。

优先级队列的排序方式其实是堆排序，但是怎么控制建大堆还是建小堆呢？

难道要去修改

这里的大于号吗？

显然是不是的；

这里介绍到仿函数：

用类重载（），行成仿函数

 

用less定义一个对象，对象调用operator（）的时候就像是函数调用，所以称为仿函数

 

在priority_queue类中增加模板参数

修改后的代码：

#pragma once
#include<vector>
#include<iostream>
using namespace std;

namespace my_priority_queue
{
    template<class T>
    class less
    {
    public:
        bool operator()(const T& l, const T& r)
        {
            return l < r;
        }
    };
    template<class T>
    class greatrer
    {
    public:
        bool operator()(const T& l, const T& r)
        {
            return l > r;
        }
    };



    template<class T,class Container=vector<T>,class Compare=less<T>>
    class priority_queue
    {
    public:
        Compare com;
        template<class IputeIterator>
        priority_queue(IputeIterator first, IputeIterator last)
        {
            while (first != last)
            {
                _con.push_back(*first);
                ++first;
            }
            for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
            {
                adjust_down(i);
            }
        }

        priority_queue()
        {

        }

        size_t size()
        {
            return _con.size();
        }

        void adjust_up(int child)
        {
            int parent = (child - 1) / 2;
            while (child > 0)
            {
                if (com(_con[parent], _con[child]))
                {
                    std::swap(_con[child], _con[parent]);
                    child = parent;
                    parent = (child - 1) / 2;
                }
                else
                {
                    break;
                }
            }
        }
        T& top()
        {
            return _con.front();
        }

        void push(const T& val)
        {
            _con.push_back(val);
            adjust_up(_con.size() - 1);
        }

        void adjust_down(int parent)
        {
            int child = parent * 2 + 1;
            while (child < _con.size())
            {
                if (child+1<_con.size()&&com(_con[child] , _con[child + 1]))
                {
                    child += 1;
                }
                if (com(_con[parent], _con[child]))
                {
                    std::swap(_con[child], _con[parent]);
                    parent = child;
                    child = parent * 2 + 1;
                }
                else
                {
                    break;
                }

            }
            
        }

        void pop()
        {
            std::swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();
            adjust_down(0);
        }

        ~priority_queue()
        {

        }

        bool empty()
        {
            return _con.empty();
        }

    private:
        Container _con;
    };

    void test_priority_queue()
    {
        int arry[] = { 1,2,3,4,5,6,7,8,9,0 };
        priority_queue<int>ls;
        priority_queue<int>ls1(arry, arry+10);

        ls.push(1);
        ls.push(2);
        ls.push(3);
        ls.push(4);
        ls.push(5);

        while (!ls.empty())
        {
            cout << ls.top() << endl;
            ls.pop();
        }
    }

}