C++中 queue 、 deque、priority_queue详解

时间 2020-08-04 标签 c++ queue deque priority 详解

最近看到一道题用到了队列，在这里就具体的分析一下C++中的这三种队列的区别

queue

用法：
ios

#include <iostream>
#include <queue>
using namespace std;
 
 
int main()
{
	queue<int> myQueue;
	cout << myQueue.empty() << endl;
	cout << myQueue.size()<< endl;
	myQueue.push(1);
	myQueue.push(2);
	myQueue.push(3);
	cout << myQueue.front()<<endl;
	cout << myQueue.back()<<endl;
	myQueue.pop();
	cout << myQueue.front()<<endl;
	cout << myQueue.back()<<endl;	
	return 0;
}

结果：
web

deque

deque是双向队列Double ended queue；can be accessed with random access iterator数组
deque是双端队列，是能够在两端扩展和收缩的连续容器。通常deque的实现是基于某种形式的动态数组，容许单个元素用随机获取less
迭代器随机读取，数组容量自动管理。dom
所以它有和vector类似的函数，但在序列的开始也有高效的插入和删除。但不像vector，deque的元素并非严格连续存储的。svg
vector和deque有类似的接口和类似的目的，但内部实现大相径庭函数

#include <iostream>
#include <deque>
using namespace std;
 
 
int main()
{
	deque<int> myDeque;
	myDeque.push_front(1);
	myDeque.push_front(2);
	myDeque.push_back(3);
	myDeque.push_back(4);
	myDeque.push_back(5);
	myDeque.push_front(6);
	myDeque.pop_back();
	deque<int>::iterator myItor;
	for(myItor=myDeque.begin(); myItor!=myDeque.end(); myItor++)
		cout<<*myItor<<endl;
		
	return 0;
}

执行结果：
spa

priority_queue

既然是队列那么先要包含头文件#include code
优先队列具备队列的全部特性，包括基本操做，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的
定义：priority_queue<Type, Container, Functional>
Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，好比vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 就是比较的方式，当须要用自定义的数据类型时才须要传入这三个参数，使用基本数据类型时，只须要传入数据类型，默认是大顶堆
通常是：xml

//升序队列 
priority_queue <int,vector<int>,greater<int> > q; 
//降序队列
 priority_queue <int,vector<int>,less<int> >q; 

//greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了相似函数的行为，就是一个仿函数类了）

基本类型例子：

#include<iostream> 
#include <queue> 
using namespace std; 

int main() 
{ 
//对于基础类型 默认是大顶堆 
priority_queue<int> a;
 //等同于 priority_queue<int, vector<int>, less<int> > a;
 //             这里必定要有空格，否则成了右移运算符↓ 
 priority_queue<int, vector<int>, greater<int> > c; 
 //这样就是小顶堆 priority_queue<string> b;
  for (int i = 0; i < 5; i++)
  { 
  	a.push(i); 
  	c.push(i); 
  } 
  while (!a.empty())
  { 
   	cout << a.top() << ' '; a.pop();
  }
  cout << endl;
  while (!c.empty()) 
  { 
      cout << c.top() << ' ';
       c.pop(); 
  } 
  cout << endl; 
  b.push("abc"); 
  b.push("abcd"); 
  b.push("cbd"); 
  while (!b.empty()) 
  { 
  	cout << b.top() << ' '; 
  	b.pop();
   } 
   cout << endl; return 0; 
   }

输出：

4 3 2 1 0
0 1 2 3 4
cbd abcd abc

pari的比较，先比较第一个元素，第一个相等比较第二个

#include <iostream> 
#include <queue> 
#include <vector> 
using namespace std;
 int main() 
 { 
 	priority_queue<pair<int, int> > a; 
 	pair<int, int> b(1, 2);
 	 pair<int, int> c(1, 3); 
 	 pair<int, int> d(2, 5); 
 	 a.push(d); 
 	 a.push(c);
 	 a.push(b); 
 	 while (!a.empty()) 
 	 { 
 	 	cout << a.top().first << ' ' << a.top().second << '\n'; 
 	 	a.pop(); 
 	 } 
}

结果：

2 5
1 3
1 2

对于自定义类型

#include <iostream>
#include <queue>
using namespace std;

//方法1
struct tmp1 //运算符重载<
{
    int x;
    tmp1(int a) {x = a;}
    bool operator<(const tmp1& a) const
    {
        return x < a.x; //大顶堆
    }
};

//方法2
struct tmp2 //重写仿函数
{
    bool operator() (tmp1 a, tmp1 b) 
    {
        return a.x < b.x; //大顶堆
    }
};

int main() 
{
    tmp1 a(1);
    tmp1 b(2);
    tmp1 c(3);
    priority_queue<tmp1> d;
    d.push(b);
    d.push(c);
    d.push(a);
    while (!d.empty()) 
    {
        cout << d.top().x << '\n';
        d.pop();
    }
    cout << endl;

    priority_queue<tmp1, vector<tmp1>, tmp2> f;
    f.push(c);
    f.push(b);
    f.push(a);
    while (!f.empty()) 
    {
        cout << f.top().x << '\n';
        f.pop();
    }
}

输出：