栈和队列以及优先级队列

目录

1.栈

2.队列

3.优先级队列

---

1.栈

栈的实现非常简单，因为所有函数都可以去调用，适配器默认为 deque<T>

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

		void push(const T& num)
		{
			_Con.push_back(num);
		}

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

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

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

		size_t top()
		{
			return _Con.back();
		}

	private:
		Container _Con;
	};

	void TestStack01()
	{
		Stack<int> st1;
		st1.push(1);
		st1.push(2);
		st1.push(3);
		st1.push(4);
		st1.push(5);

		while (st1.size())
		{
			int top = st1.top();
			st1.pop();

			cout << top << ' ';
		}
		cout << endl;
	}
};

2.队列

与栈的实现类似，只不过是先进先出原则

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

		void push(const T& num)
		{
			_Con.push_back(num);
		}

		size_t size()
		{
			return _Con.size();
		}
			
		bool empty()
		{
			return _Con.empty();
		}

		size_t front()
		{
			return _Con.front();
		}

		size_t back()
		{
			return _Con.back();
		}

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

	private:
		Container _Con;
	};

	void TestQueue01()
	{
		Queue<int> q1;
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);
		q1.push(5);

		while (q1.size())
		{
			int front = q1.front();
			q1.pop();

			cout << front << ' ';
		}
		cout << endl;
	}
};

3.优先级队列

他的底层结构为堆，因此与堆的实现非常相似，无非就是加上了一层封装。

在堆中最重要的两个结构无非就是向上调整和向下调整

实现了这两个，其他都是小case

namespace PQ_YC
{
    template <class T, class Container = vector<T>>
    class priority_queue
    {
    public:
        priority_queue()
        {}
        
        void Adjustup(size_t son)
        {
            int parent = (son - 1) / 2;
            while (son)
            {
                if (_Con[parent] < _Con[son])
                {
                    swap(_Con[parent], _Con[son]);
                    son = parent;
                    parent = (son - 1) / 2;
                }
                else
                {
                    break;
                }
            }
        }

        void Adjustdown(size_t parent)
        {
            int son = parent * 2 + 1;

            while (son < _Con.size())
            {
                if (son + 1 < _Con.size() && _Con[son] < _Con[son + 1])
                    son++;

                if (_Con[son] > _Con[parent])
                {
                    swap(_Con[son], _Con[parent]);
                    parent = son;
                    son = parent * 2 + 1;
                }
                else
                {
                    break;
                }
            }
        }

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

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

        const T& top() const
        {
            return _Con[0];
        }

        void push(const T& x)
        {
            _Con.push_back(x);
            Adjustup(_Con.size() - 1);
        }

        void pop()
        {
            swap(_Con[0], _Con[_Con.size() - 1]);
            _Con.pop_back();
            Adjustdown(0);
        }
    private:
        Container _Con;
    };

    void TestPriority_queue01()
    {
        priority_queue<int> pq1;
        pq1.push(10);
        pq1.push(8);
        pq1.push(6);
        pq1.push(7);
        pq1.push(4);
        pq1.push(3);
        pq1.push(2);
        pq1.push(5);
        pq1.push(1);

        while (pq1.size())
        {
            int top = pq1.top();
            pq1.pop();

            cout << top << ' ';
        }
        cout << endl;
    }
};