精华内容
下载资源
问答
  • 对labview中队的使用做一个详细地说明,这是学队列的使用最基础的一个例程。
  • 队列列列列!!!!! Time Limit: 1000 MS Memory Limit: 32768 K Total Submit: 337(148 users) Total Accepted: 154(142 users) Rating: Special Judge: No Description ...
    队列列列列!!!!!
    Time Limit: 1000 MSMemory Limit: 32768 K
    Total Submit: 337(148 users)Total Accepted: 154(142 users)Rating: Special Judge: No
    Description


    xuxu完成了栈的实验要求后,他又很是开心,刚要出去liuda, biaobiao突然问道老师让做的队列的那个实验你写完了么,xuxu顿时大呼悲哉。。。。他给忘记了,怎么办。。明天就要上交实验报告了,你能帮他搞定么???

    你需要完成三种操作1.enqueue x,将元素x插入队尾。2.dequeue,若队列非空,则删去队头元素,并输出该元素。3.query,从队头开始删除所有元素,并输出。



    Input
    本题有多组测试数据,每组数据首先输入一个T,接下来T行是T种对队列的操作。  (0< T < 100,0< x <= 500)

    Output

    每次执行dequeue操作时删除队头元素输出并换行,如果队列为空输出“this is empty!”并换行。

    每次执行query操作时删除所有元素队列内所有元素并输出,每个元素占一行,如果栈为空输出“this is empty!”并换行。

    每组数据后有一个空行。

    Sample Input
    10
    enqueue 1
    enqueue 2
    enqueue 3
    enqueue 4
    query
    dequeue
    enqueue 1
    dequeue
    query
    dequeue
    Sample Output
    1
    2
    3
    4
    this is empty!
    1
    this is empty!
    this is empty!
    Source
    新生练习赛(2013.11.16)
    Author

    cyh@hrbust

     

    太不小心了,因为 之前太顺手了,没想到理工题……。

    但是这次题意理解错了一点儿wa三次;这个题 明显是队列知识用法练习,很好的能够锻炼掌握新学的知识!

    #include<iostream>
    #include<queue>
    #include<string>
    using namespace std;
    int main()
    {
    	int T,x;
    	string str;
    	while(cin>>T)
    	{
    		queue<int>gq;
    		for(int i=0;i<T;i++)
    		{
    			cin>>str;
    			if(str[0]=='e')
    			{
    				cin>>x;
    				gq.push(x);
    			}
    			else if(str[0]=='q')
    			{
    				if(gq.empty())
    					cout<<"this is empty!"<<endl;
    				else
    				{
    					while(!gq.empty())
    					{
    						cout<<gq.front()<<endl;
    						gq.pop();
    					}
    				}
    			}
    			else if(str[0]=='d')
    			{
    				if(gq.empty())
    					cout<<"this is empty!"<<endl;
    				else
    				{
    					cout<<gq.front()<<endl;
    					gq.pop();
    				}
    			}
    		}
    		cout<<endl;
    	}
    	return 0;
    }
    		
    


     

    展开全文
  • 由对的特性,银行排队为例, 队列应该包含如下基本操作: 加入队列(取号) enqueue 从队列中移除(办理业务离开) dequeue 当前排队号码(呼叫下一个人) peek 当前队列长度(当前排队人数) size 判断队列是不是空 ...
  • 调用C++STL中的队列,优先队列及双端队列

    【队列queue】

    头文件:#include <queue>
    普通声明:queue<int> q;
    结构体:

    struct node{
        int x,y;
    };
    queue<node>   q;
    

    转自: C++ 队列queue的用法
    C++队列queue模板类的定义在<queue>头文件中,queue 模板类需要两个模板参数,一个是元素类型,一个容器类型,元素类型是必要的,容器类型是可选的,默认为deque 类型。
    C++队列Queue是一种容器适配器,它给予程序员一种先进先出(FIFO)的数据结构。

    C++队列Queue类成员函数如下:
    back()返回最后一个元素
    empty()如果队列空则返回真
    front()返回第一个元素
    pop()删除第一个元素
    push()在末尾加入一个元素
    size()返回队列中元素的个数

    queue 的基本操作举例如下:
    queue入队,如例:q.push(x); 将x 接到队列的末端。
    queue出队,如例:q.pop(); 弹出队列的第一个元素,注意,并不会返回被弹出元素的值。
    访问queue队首元素,如例:q.front(),即最早被压入队列的元素。
    访问queue队尾元素,如例:q.back(),即最后被压入队列的元素。
    判断queue队列空,如例:q.empty(),当队列空时,返回true。
    访问队列中的元素个数,如例:q.size()

    【优先队列priority_queue】

    优先队列容器与队列一样,只能从队尾插入元素,从队首删除元素。但是它有一个特性,就是队列中最大的元素总是位于队首,所以出队时,并非按照先进先出的原则进行,而是将当前队列中最大的元素出队。元素的比较规则默认按元素值由大到小排序,可以重载“<”操作符来重新定义比较规则。

    队列和优先级队列的头文件都是#include <queue>
    下面这篇转自: C++(标准库)栈和队列以及优先队列的使用

    使用标准库的栈

    #include <stack>    //头文件
    stack<int> s;      //定义一个 int 型的栈
    s.empty()       //如果栈为空返回true,否则返回false
    s.size()           //返回栈中元素的个数
    s.pop()           //删除栈顶元素但不返回其值
    s.top()            //返回栈顶的元素,但不删除该元素
    s.push()          //在栈顶压入新元素
    

    使用标准库的队列

    #include <queue>  //头文件
    queue<int> q;      //定义一个 int 型的队列
    q.empty()       //如果队列为空返回true,否则返回false
    q.size()           //返回队列中元素的个数
    q.pop()           //删除队列首元素但不返回其值
    q.front()         //返回队首元素的值,但不删除该元素
    q.push()          //在队尾压入新元素
    q.back()          //返回队列尾元素的值,但不删除该元素
    

    优先队列
    优先级队列支持的操作

    q.empty()          //如果队列为空,则返回true,否则返回false
    q.size()              //返回队列中元素的个数
    q.pop()              //删除队首元素,但不返回其值
    q.top()               //返回具有最高优先级的元素值,但不删除该元素
    q.push(item)      //在基于优先级的适当位置插入新元素
    

    测试代码:C++(标准库)栈和队列以及优先队列的使用
    声明方式:
    1.普通方式:

    priority_queue<int> q;
    //通过操作,按照元素从大到小的顺序出队
    priority_queue<int,vector<int>,greater<int> > q;
     //通过操作,按照元素从小到大的顺序出队
    

    2.自定义优先级:

    struct cmp {    
      operator bool ()(int x, int y)     
      {        
         return x > y; // x小的优先级高      
         //也可以写成其他方式,如: return p[x] > p[y];表示p[i]小的优先级高
      }
    };```
    priority_queue<int, vector<int>, cmp>q;    //定义方法
    //其中,第二个参数为容器类型。第三个参数为比较函数。
    

    3.结构体声明方式

    struct node {     
      int x, y;     
      friend bool operator < (node a, node b)     {         
        return a.x > b.x;    //结构体中,x小的优先级高     
      }
    };
    priority_queue<node>q;   //定义方法
    //在该结构中,y为值, x为优先级。
    //通过自定义operator<操作符来比较元素中的优先级。
    //在重载”<”时,最好不要重载”>”,可能会发生编译错误
    

    【双端队列】

    双端队列用法

    1、如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector
    2、如果你需要大量的插入和删除,而不关心随即存取,则应使用list
    3、如果你需要随即存取,而且关心两端数据的插入和删除,则应使用deque。
    //创建deque

    deque<int> d1; //创建一个没有任何元素的deque对象
    deque<int> 2(10);//创建一个具有10个元素的deque对象,每个元素值为默认
    deque<double> d3(10, 5.5); //伊妹一个具有10个元素的deque对象,每个元素的初始值为5.5
    deque<double> d4(d3); //通过拷贝一个deque对象的元素值, 创建一个新的deque对象
    

    //初始化赋值:同vector一样,使用尾部插入函数push_back()

    for (int i = 1; i < 6 ; i++) d1.push_back(i*10);
    cout<<"printDeque(d1) : "<<endl;
    printDeque(d1);
    

    遍历元素: 1-下标方式 2-迭代器方式 反向遍历(略)

    //元素插入:尾部插入用push_back(),头部插入用push_front(),其它位置插入用insert(&pos, elem)
    cout<<"d1.push_front(100): "<<endl;
    d1.push_front(100);
    printDeque(d1);
    cout<<"d1.insert(d1.begin()+3, 200): "<<endl; //支持随机存取(即[]操作符),所以begin()可以+3
    
    d1.insert(d1.begin()+2,200);
    
    printDeque(d1);
    
    //元素删除 尾部删除用pop_back();头部删除用pop_front(); 
    
    //任意迭代位置或迭代区间上的元素删除用erase(&pos)/erase(&first, &last);删除所有元素用clear();
    cout<<"d1.pop_front(): "<<endl;
    d1.pop_front();
    
    printDeque(d1);
    cout<<"d1.erase(d1.begin()+1): "<<endl;
    d1.erase(d1.begin()+1); //删除第2个元素d1[1]
    printDeque(d1);
    
    cout<<"d1.erase(d1.begin(), d1.begin() + 2) = "<<endl;
    d1.erase(d1.begin(), d1.begin() + 2);
    printDeque(d1);
    
    cout<<"d1.clear() :"<<endl;
    d1.clear();
    printDeque(d1);
    
    //其它常用
    cout<<"其它常用用法: "<<endl;
    int flag = 0;
    while(flag < 2){
       if (0 == flag ) {
        for (int i = 1; i < 6 ; i++) //恢复
         d1.push_back(i*10);
       }
       else {
        d1.clear();
        cout<<"after d1.clear() , d1.front(), d1.back() is abnormal! other info.:"<<endl;
       }
       cout<<"d1.empty() = "<<d1.empty()<<endl;
       cout<<"d1.size() = "<<d1.size()<<endl;
       cout<<"d1.max_size() = "<<hex<<d1.max_size()<<endl;
       if (!d1.empty()){
        cout<<"d1.front() = "<<d1.front()<<endl;
        cout<<"d1.back() = "<<d1.back()<<endl;
       }
       flag++;
    }
    //交换
    cout<<"d1.swap(d5)= "<<endl;
    d1.swap(d5);
    cout<<"d1 = ";
    printDeque(d1);
    cout<<"d5 = ";
    printDeque(d5);
    //printDeque(d)
    }
    

    另一篇转自:双端队列(deque)–课堂跳了的内容

    展开全文
  • 《栈 队列》——栈与队列(Java)

    千次阅读 2016-05-19 21:13:27
    一:对 队列是一种先进先出的数据结构 实现代码: package Queue; /* * 使用java构建队列,并模拟实现队列的入队和出对方法 */ public class Queue { //队列类 private int maxSize; //定义队列的长度 ...

    一:对列

    队列是一种先进先出的数据结构

    实现代码:

    package Queue;
    
    /*
     * 使用java构建队列,并模拟实现队列的入队和出对方法
     */
    
    public class Queue {     //队列类
    
    	private int maxSize;  //定义队列的长度
    	private int[] arrQueue;      //队列
    	private int rear;     //定义队列的尾指针
    	private int front;   //定义队列的头指针
    	private int empty;  //元素的个数
    	
    	public Queue(int s)   //初始化构造函数
    	{
    		maxSize = s;
    		arrQueue = new int[s];
    		rear = -1;
    		front=0;
    		empty = 0;
    	}
    	
    	//实现插入方法
    	public void insert(int m)
    	{
    		if(rear == maxSize-1)   //处理循环
    			rear = -1;      
    		arrQueue[++rear] = m;   //对尾指针加一,把值放在队列结尾
    		empty++;      //队列元素个数加1
    		System.out.println("队列入队元素 为:" + m);
    	}
    	
    	//实现出栈的方法,即取得队列的头元素
    	public int remove()
    	{
    		int temp = arrQueue[front++]; //将栈顶元素赋值给temp,栈顶指针加1
    		if(front == maxSize) //处理循环
    			front = 0;
    		empty--; //元素个数-1
    		return temp;
    	}
    	
    	//判断队列是否为空
    	public boolean isEmpty()
    	{
    		return (empty==0);
    	}
    	
    	//判断对列是否为满
    	public boolean isFull()
    	{
    		return (empty == maxSize);
    	}
    	
    	//返回队列长度
    	public int qLong()
    	{
    		return empty;
    	}
    	
    	public static void main(String[] args) {
    		Queue q = new Queue(5); //初始化队列为5个元素
    		
    		q.insert(1);
    		q.insert(2);
    		q.insert(3);
    		q.insert(4);
    		q.insert(5);
    		
    		int t1 = q.remove();
    		System.out.println("队列元素出队:" + t1);
    		int t2 = q.remove();
    		System.out.println("队列元素出队:" + t2);
    		
    		System.out.println("队列是否为空:" + q.isEmpty());
    		System.out.println("队列是否为满:" + q.isFull());
    		System.out.println("队列的长度:" + q.qLong());
    	}
    	
    }
    

    二:栈

    栈是一种先进后出的数据结构

    1:使用数组模拟栈

    package Statck;
    /*
     * 使用java构建栈,并模拟实现栈的入栈和出栈方法
     * 使用数组实现
     */
    
    public class Statck1 {
    
    	private int maxSize;     //栈的最多元素数
    	private int top;    //栈顶指针
    	private int len;     //栈的深度
    	private int[] arrStack; // 模拟栈
    	
    	//栈的初始化
    	public Statck1(int s){
    		maxSize = s;
    		len =0;
    		top= -1;
    		arrStack = new int[s];
    	}
    	
    	//获取栈的长度
    	public int getLen(){
    		return len;
    	}
    	
    	//获取当前栈还能插入多少个f元素
    	public int getLeaveLen(){
    		return (maxSize-len);
    	}
    	//判断栈是否满
    	public boolean isFull(){
    		return (len==maxSize);
    	}
    	
    	//判断栈是否为空
    	public boolean isEmpty(){
    		return (len ==0);
    	}
    	
    	//元素入栈
    	public void inStack(int s)
    	{
    		arrStack[++top] = s; //栈顶指针加1,入栈
    		System.out.println("元素入栈:" + s);
    		len ++ ;//栈深度+1
    	}
    	
    	//元素出栈
    	public int outStack()
    	{
    		int temp = arrStack[top--];//赋值之后减1
    		System.out.println("元素出栈:" + temp);
    		len--;   //栈深度-1
    		return temp;
    	}
    	
    	public static void main(String[] args) {
    		Statck1 s = new Statck1(5);
    		
    		s.inStack(1);
    		s.inStack(2);
    		s.inStack(3);
    		s.inStack(4);
    		s.inStack(5);
    		
    		s.outStack();
    		s.outStack();
    		System.out.println("栈的长度:" + s.getLen());
    		System.out.println("还能入栈元素个数:" + s.getLeaveLen());
    		System.out.println("栈的是否为空:" + s.isEmpty());
    		System.out.println("栈的是否为满:" + s.isFull());
    	}
    }
    

    2:使用链表模拟栈

    package Statck;
    
    import java.util.ArrayList;
    import java.util.EmptyStackException;
    import java.util.List;
    
    /*
     * 使用java构建栈,并模拟实现栈的入栈和出栈方法
     * 使用链表实现
     */
    
    public class Statck2<E extends Object> {  
    	
        private List<E> statck = new ArrayList<E>(); 
    	
    	public Statck2(){
    		      //栈的初始化
    	}
    	
    	//清空栈
    	public void clear(){
    		statck.clear();
    		System.out.println("清空栈..........");
    	}
    	//判断栈是否为空
    	public boolean isEmpty(){
    		return statck.isEmpty();
    	}
    	//获取栈顶元素
    	public E getTop(){
    		if(isEmpty())
    			return null;
    		return statck.get(0);
    	}
    	
    	//弹出栈操作
    	public E pop(){
    		if (isEmpty()) 
    			throw new EmptyStackException();  
    		System.out.println(statck.size() + "\t 出栈");
            return statck.remove(statck.size() - 1);  
    	}
    	
    	//压入栈操作
    	public void push(E e){
    		statck.add(e);
    		System.out.println(e + "\t 入栈");
    	}
    	
    	//获取当前栈的深度
    	public int getStatckSize(){
    		if(isEmpty())
    			throw new EmptyStackException();
    		return statck.size();
    	}
    	
    	public static void main(String[] args) {
    		Statck2 s = new Statck2();
    		s.clear();           //清空栈
    		System.out.println("当前栈是否为空:" + s.isEmpty());
    		s.push(1);
    		s.push(2);
    		s.push(3);
    		
    		s.pop();
    		System.out.println("当前栈的深度为:" + s.getStatckSize());
    		System.out.println("当前栈顶元素为:" + s.getTop());
    	}
    	
    }
    


    展开全文
  • 队列和全局对

    2018-04-07 23:12:21
    队列:全局串行对全局对:全局并发对

    主队列:全局串行对列


    全局对列:全局并发对列

    展开全文
  • 每一个应用程序只有一个主线程即只有一个主队 在线程间通信中一定会使用,文章链接 http://blog.csdn.net/sinat_20559947/article/details/52608333 主队列 : 在主线程 全局队列 : 在子线程 #pragma mark -...
  • 队列

    千次阅读 2021-01-18 18:20:38
    二、队列里面要知道的概念1.出列2.入列3.空队列上例题Java/C代码 前言 没想到吧,我皮某人又回来了。 经过这么久的偷懒,哦不,沉淀,于2021年1月18号回归写博客的日子。回想那段日子,仿佛就这昨天 别bb了,快上...
  • 阻塞队列,有界队列,无界队列

    千次阅读 2021-03-12 16:01:58
    在并发编程中,有时候需要使用线程安全的队列。如果要实现一个线程安全的队列有两种方式:一种是使用阻塞算法,另一种是使用非阻塞算法。 使用阻塞算法的队列可以用一个锁(入队和出队用同一把锁)或两个锁(入队和...
  • 链对初始化/入队列/出队列/判空

    千次阅读 2015-11-23 10:29:47
    //链队列,链队列实质上是单链表,为了操作方便,需要设置队头和队尾两个指针,并放在一个结构体内, //采用带头结点的单链表,使得队空与非空具有同一结构形式。 //链队列中结点类型 struct node{ int data ; ...
  • java队列实现(顺序队列、链式队列、循环队列
  • 软考——队列与双端对

    千次阅读 热门讨论 2016-10-30 17:14:37
    这两天做题的时候遇到了双端对的题,和大家分享一下。 一、队列和栈  队列和栈我们都不陌生,学过数据结构的同学应该都知道在顺序结构中有这么两中存放数据的容器。  队列:在队列中,数据的进出方法...
  • 队列、双端队列与优先队列

    千次阅读 2017-03-20 14:12:22
    队列、双端队列与优先队列 队列:先进先出,从后面插入,从前面移除;处理类似排队的问题,先排先处理,插入和移除操作的时间复杂度都为O(1)。 双端队列:即在队列两端都可以插入和删除。同时拥有栈和队列的功能,...
  • DS队列队列

    千次阅读 2018-09-25 19:33:05
    组队包含两种命令: 1、 ENQUEUE,表示当有新的元素进入队列,首先会检索是否有同一组的元素已经存在,如果有,则新元素排在同组的最后,如果没有则插入队列末尾。 2、 DEQUEUE,表示队列头元素出队 3、 STOP,...
  • C语言实现有锁队列

    万次阅读 2021-04-06 18:18:49
    不同于无锁队列,有锁队列是在入列或者出列时,为队列上锁,这样保证代码在运行时同一时间只能有一种操作,因此避免了资源的抢占。 使用场景 生产消费者模型之类的场景可以使用。 二、代码 头文件定义 我们定义一...
  • labview中队的应用,两个VI如何用队列进行数据共享。
  • 大型网站架构之分布式消息队列

    万次阅读 多人点赞 2016-01-26 08:48:40
    大型网站架构之分布式消息队列   以下是消息队列以下的大纲,本文主要介绍消息队列概述,消息队列应用场景和消息中间件示例(电商,日志系统)。 本次分享大纲 消息队列概述消息队列应用场景消息中间件示例...
  • C++数据结构——队列

    万次阅读 多人点赞 2018-06-26 22:20:30
    C++数据结构——队列参考博客:http://www.cnblogs.com/QG-whz/p/5171123.htmlhttp://www.169it.com/article/2718050585107790752.html1、队列(Queue)与栈一样,是一种线性存储结构,它具有如下特点:(1)队列中...
  • Python 队列

    万次阅读 多人点赞 2018-06-28 15:42:29
    队列是线性的集合,对于队列来说,插入限制在一端(队尾),删除限制在另一端(队头)。队列支持先进先出(FIFO)的协议。我们在后面会提到一种特殊的队列——优先队列,在优先队列中,具有较高优先级的项会在那些...
  • 一个简单的优先级队列,设计用于 1xN matlab 向量,其中可以在构造过程中定义比较器。 即使队列较大(100,000 个元素),使用 minheap 也能确保快速操作。 当前实现了以下方法:插入、删除、查看、大小、清除、...
  • 消息队列

    千次阅读 多人点赞 2019-09-19 21:42:59
    消息队列 “消息队列”是在消息的传输过程中保存消息的容器,当我们需要使用消息的时候可以取出消息供自己使用。 消息队列中间件是分布式系统中重要的组件,主要解决应用解耦,异步消息,流量削锋等问题,实现高...
  • Java队列介绍&用队列实现栈

    万次阅读 2020-06-04 16:40:58
    本文将介绍队列的概念以及Java中队Queue的继承关系。第二部分将用队列实现栈。
  • 队列 队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端...
  • STL队列

    2018-04-22 19:35:23
    STL中队(queue)的使用方法 push(x) 将x压入队列的末端 pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值 front() 返回第一个元素(队顶元素) back() 返回最后被压入的元素(队尾元素) empty() ...
  • 公司小伙伴反馈自己负责的RocketMq集群忽然有两个队列不消费了,消息堆积达到了1万多条,这个肯定不正常。 以下是当时的消费组的实际消费情况 从上面的图中可以看出来,有两个队列严重阻塞了,好久没有上报过offset...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 227,762
精华内容 91,104
关键字:

列队列