栈&队列

队列部分

普通队列

　　举个形象的例子：排队买票。

　　有一列人在排队买票，前面来的人买完票就离开，后面来的人需要站在最后……依次类推。

　在计算机中，数据结构队列有一个头指针和尾指针，头指针加一就代表有一个数据出队了（人买完票），尾指针加一就代表有一共数据入队了。

　　队列，是一种线性表结构。它的主体是一个数组，第一个队内元素所在的位置叫做队首，而最后一个元素所在的位置叫做队尾。队列允许在队首队尾进行操作。因此，队列具有一个特殊而重要的性质FIFO（先进先出）。

　　普通队列大概是这个样子的：

普通队列实现

手写实现：

#include <iostream>
using namespace std;
struct queue//将队列封装在一个结构体中
{
	int head=0,tail=0;//head代表头指针，tail代表尾指针
	int a[100];//队列元素存储于此
	void pop(){head++;}//弹出队头元素
	void push(int num){a[tail]=num;tail++;}//在队尾插入元素
	int size(){return tail-head;}//判断队列元素个数
	int back(){return a[tail-1];}//返回队尾元素
	int front(){return a[head];}//返回队头元素
	bool empty(){if(head==tail)return true;return false;}//判断队列是否为空
};
int main()
{
	//测试手写队列
	queue q;
	q.push(1);
	cout<<q.front()<<endl;
	q.pop();
	if(q.empty())q.push(2);
	cout<<q.front()<<endl;
	q.push(3);
	cout<<q.back()<<endl;
	cout<<q.size();
	return 0;
}

STL实现：

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
int main()
{
	queue<int>q;
	q.pop();//弹出队头元素
	q.push(1);//将1这个元素插入队尾
	q.size();//判断队列元素个数
	q.front();//返回队头元素
	q.back();//返回队尾元素
	q.empty();//判断队列是否为空
	return 0;
}

单调队列

　　顾名思义，单调队列可以保证队内元素时刻保持单调（单调递增、单调递减、单调非减、单调非增）。

　　单调队列虽然叫“队列”，但其实和队列有很大差别：为了保证队内元素单调，会强行舍弃队中的一些元素。这点与FIFO的队列有很大不同，所以应该把单调队列看作是原数列的一个单调子序列。

　　另外，与普通队列不同的是，单调队列可以在队头和队尾插入和删除元素。

优先队列

　　顾名思义，优先队列就是指队列中的每一个元素都有一个优先级，优先级可以是最大的元素优先级最大，也可以是最小的元素优先级最大，具体看优先队列的定义。

　　优先队列，其实在本质上与堆没有多大的区别。

优先队列实现

手写实现：

#include <iostream>
#define cmp(a,b) (a>b)//如果要修改元素优先级，在这里修改
#define sort(h,t) for(int i=t-1;cmp(a[i],a[i-1])&&i>=h;i--)swap(a[i],a[i-1])
using namespace std;
struct priority_queue//默认最大的元素优先级最大的优先队列
{
    int head=0,tail=0;//head代表头指针，tail代表尾指针
    int a[100];//队列元素存储于此
    void pop(){head++;}//弹出队头元素
    void push(int num){a[tail]=num;tail++;sort(head,tail);}//在队尾插入元素，改变元素优先级
    int size(){return tail-head;}//判断队列元素个数
    int top(){return a[head];}//返回队头(优先级最高)的元素
    bool empty(){if(head==tail)return true;return false;}//判断队列是否为空
};
int main()
{
    //测试
    priority_queue q;
    q.push(1);q.push(2);q.push(3);
    cout<<q.size()<<endl;
    cout<<q.top()<<endl;
    q.pop();
    cout<<q.top()<<endl;
    q.pop();
    cout<<q.top()<<endl;
    q.pop();
    if(q.empty())q.push(1);
    cout<<q.top();
    return 0;
}

STL实现：

#include <iostream>
#include <queue>
using namespace std;
int main()
{
	priority_queue<int>q;
	q.pop();//弹出队头元素
    q.push(1);//将1这个元素插入队尾
    q.size();//判断队列元素个数
    q.top();//返回队头(优先级最高)的元素
    q.empty();//判断队列是否为空
    return 0;
}

栈部分

　　栈，是一种数据结构，它具有先进后出(FILO)的特性，意思是，第一个进入的元素，是最后出来的，这与队列完全是相反的。

　　举个形象的例子：从羽毛球筒里拿羽毛球。

　　有一个羽毛球筒，只有一个开口，里面放满了羽毛球，这时，你想拿最底下的羽毛球，你会怎么做呢？

　　答案是：把前面所有的羽毛球都拿出来，最后拿最底下的。

　　这就运用了栈的思想，栈最主要的特点就是先进后出(FILO)。

　　栈大概长这样：

栈实现

手写实现：

#include <iostream>
using namespace std;
struct stack//将栈封装在一个结构体当中
{
    int a[100];//栈元素存在此中
    int Top=0;//栈顶
    void pop(){Top--;};//弹出栈顶元素
    void push(int num){a[Top]=num;Top++;}//将元素插入栈顶
    int top(){return a[Top];}//返回栈顶元素
    int size(){return Top;}//判断栈元素个数
    bool empty(){if(!Top)return true;return false;}//判断栈是否为空
};
int main()
{
    //测试
    stack s;
    s.push(1);
    cout<<s.top()<<endl<<s.size()<<endl;
    s.pop();
    if(s.empty())s.push(2);
    cout<<s.top();
    return 0;
}

STL实现：

#include <iostream>
#include <stack>
using namespace std;
int main()
{
    stack<int>s;
    s.pop();//弹出栈顶元素
    s.push(1);//将1这个元素插入栈顶
    s.top();//返回栈顶元素
    s.size();//判断栈元素个数
    s.empty();//判断栈是否为空
    return 0;
}