精华内容
下载资源
问答
  • 队列——链队列和循环队列

    千次阅读 2018-11-03 16:02:15
    队列 ... 1 链队列的存储结构  将对头指针front指向链队列的头结点,队尾指针...空队列时,头指针front尾指针rear都指向头结点。   链队列的存储结构为: typedef int QElemType; typedef struct QNode...

    链队列

    转载:https://www.cnblogs.com/muzijie/p/5655228.html

    1 链队列的存储结构

      将对头指针front指向链队列的头结点,队尾指针rear指向终端结点。

    空队列时,头指针front和尾指针rear都指向头结点。

     

    链队列的存储结构为:

    typedef int QElemType;
    typedef struct QNode {            //结点结构
        QElemType data;
        struct QNode *next;
    }QNode;
    
    typedef struct QNode * QueuePtr;
    
    typedef struct {                //队列的链表结构
        QueuePtr rear;
        QueuePtr front;
    }LinkQueue;

    2 入队操作

    //插入元素e为Q的新的队尾结点
    Status EnQueue(QueuePtr Q, QElemType e) {
        QueuePtr q = (QueuePtr)malloc(sizeof(QNode));
        if (!q) {                //存储分配失败
            exit(OVERFLOW);
        }
        q->data = e;
        q->next = NULL;
        Q->rear->next = q;
        Q->rear = q;
        return OK;
    }

    3 出队操作

      出队操作,就是头结点的后继结点出队,将头结点的后继改为它后面的结点。

      若链表除头结点外只剩一个元素时,则需将rear指针指向头结点。

    //若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR。
    Status DeQueue(QueuePtr Q, QElemType *e) {
        QueuePtr q;
        if (Q->rear == Q->front) {        //空队列
            return ERROR;
        }
        q = Q->front->next;                //q指向第一个结点
        *e = q->data;
        Q->front->next = q->next;
    
        if (Q->rear == p) {                //若队头就是队尾,删除后,需要将rear指针指向头结点
            Q->rear = Q->front;
        }
        free(q);
        return OK;
    }

    4 循环队列与链队列的比较

      从时间上考虑,循环队列和链队列的基本操作都是O(1),不过循环队列是事先已申请好空间,使用期间不会释放。而对于链队列,每次申请和释放结点也会存在一些时间开销。如果入队和出队频繁,两者还是有细微差异的。
      从空间来说,循环队列必须有一个固定的长度,所以就有了存储元素个数和空间浪费的问题。而链队列不存在这个问题,尽管它需要一个指针域,会产生一些空间上的开销,但是是可以接受的。所以从空间上说,链队列更加灵活。
      总的来说,在可以确定链队列最大长度的情况下,建议使用循环队列。如果无法预估队列的长度,则使用链队列。

     

     

    循环队列

    转载:https://www.cnblogs.com/hughdong/archive/2017/05/11/6841970.html

    (作者说的挺有意思的话:You know something and I know nothing.)

            和顺序栈相类似,在队列的顺序存储结构中,除了用一组地址连续的存储单元依次存放从队头到队尾的元素外,尚需敷设两个指针front和rear分别指示队列头元素位置和队列尾元素的位置。

    如果使用顺序表作为队列的话,当处于右图状态则不能继续插入新的队尾元素,否则会因为数组越界而导致程序代码被破坏。

     

    由此产生了由链表实现的循环队列,只有队列未满时才可以插入新的队尾元素。

     

    下面内容,转载:https://www.cnblogs.com/chenliyang/p/6554141.html

            1.图中有两个指针(其实就是两个整数型变量,因为在这里有指示作用,所以这里理解为指针)front、rear,一个指示队头,一个指示队尾。

         2.rear和front互相追赶着,这个追赶过程就是队列添加和删除的过程,如果rear追到head说明队列满了,如果front追到rear说明队列。

    说明:令队列空间中的一个单元闲置,使得队列非空时,Q.rear与Q.front之间至少间隔一个空闲单。(思考为什么空一格)

         3.我们把它掰弯,用的是求余,这样两个值就不会跑出最大范围,并且可以实现弯曲的效果,所以说对于循环队列我们必须给定最大值MAXQSIZE。

       这其实是我们臆想的,反正我们要做的就是利用循环来解决空间浪费的问题。  

    循环队列的实现过程(important)

        ☆当添加一个元素时,(rear+1)%MAXQSIZE; //理解为什么求余?

        ☆当删除一个元素时,(front+1)%MAXQSIZE;//理解为什么求余?

        ☆当rear=front的时候,队列可能是满,也可能是空。(这也是为什么空一格的原因)

          因为存在满和空两种情况,我们需要分别判断:

            ☆:当队列添加元素到rear的下一个元素是head的时候,也就是转圈子要碰头了,我们就认为队列满了。(Q.rear+1)%MAXSIZE=Q.front

            ☆:当队列删除元素到head=rear的时候,我们认为队列空了。Q.rear==Q.front,不一定为0

            上面这一段要好好理解,在其他编程的地方,也会用到类似的思想。

            下面的代码思想很重要。

    2.1对节点的定义

    #define MAXQSIZE 100
    typedef int QElemtype;
    typedef int status;
    
    typedef struct{
        QElemtype *base;
        int front;
        int rear;
        }SqQueue;

    2.2初始化队列

    SqQueue* InitQueue()
    {
        SqQueue *q;
        q=new SqQueue;
        q->base=new int[MAXQSIZE];
        q->rear=q->front=0;
        return q;
    }

    2.3添加操作

    status EnQueue(SqQueue *q,QElemtype e)
    {
        //插入到队尾
        if((q->rear+1)%MAXQSIZE==q->front)
            return 0;
        q->base[q->rear]=e;
        q->rear=(q->rear+1)%MAXQSIZE;
        return 1;
    }

    2.4删除操作

    status DeQueue(SqQueue *q)
    {
        if(q->front==q->rear)
            return 0;
        printf("%d",q->base[q->front]);
        q->front =(q->front+1)%MAXQSIZE;
        return 1;
    }

    备注,这插入和删除的操作,类似于标记。(这也很重要)

    2.5获取队列长度

    int QueueLength(SqQueue *q)
    {
        return (q->rear-q->front+MAXQSIZE)%MAXQSIZE;
    }

     

    补:还有些其他的队列,比如优先队列,双端队列。(用的时候可以查STL)

    队列练习:

    团体队列

    并行程序模拟

     

    展开全文
  • 题目:用数组结构实现大小固定队列和栈 一、数组实现栈结构: 栈结构是先进后出的,只需要一个数组一个记录位置的变量size,当进来一个元素,size就++,出去一个元素size就-- public class ArrayStack{ ...

    题目:用数组结构实现大小固定的队列和栈

    一、数组实现栈结构:

            栈结构是先进后出的,只需要一个数组和一个记录位置的变量size,当进来一个元素,size就++,出去一个元素size就--

     

    public class ArrayStack{
            private Integer[] arr;
            private Integer   size;
    
            /**
             *  栈初始化
             * @param initSize 初始化数组容量
             */
            public ArrayStack(int initSize){
                if (initSize<0)
                    throw  new  IllegalArgumentException("参数不合理!");
                arr=new Integer[initSize];
                size=0;
            }
    
            /**
             * @Description: 返回栈顶元素
             * @return:  栈空 返回null 栈不空 返回栈顶元素
             * @date: 2019/4/23 10:12
             */
            public Integer peek(){
                if (size==0)
                    return null;
                Integer num = arr[size - 1];
                return num;
            }
    
            /**
             * @Description: 压栈操作
             * @param:    待压入元素
             * @date: 2019/4/23 10:15
             * @throws:  栈满时,抛出数组越界异常
             */
            public void push(int obj){
                if (size==arr.length)
                    throw new ArrayIndexOutOfBoundsException("栈满,无法压入!");
                arr[size++]=obj;
            }
    
            /**
             * @Description: 弹栈操作
             * @return:  返回栈顶元素 并数量减一
             * @date: 2019/4/23 10:19
             * @throws :  栈空时抛出数组越界异常
             */
            public Integer pop(){
                if (size==0)
                    throw new ArrayIndexOutOfBoundsException("栈空,无法弹栈!");
                return arr[--size];
            }
        }
    

    二、.实现队列结构:相对栈结构麻烦一些,队列要求先进先出,本案例中设置一个数组和三个变量,size用于记录元素总数,last记录刚进来的元素应该放在哪个位置即队尾,first表示用户要求弹出的元素所在的位置即队首。或许有些同学会觉得size是多余的,完全可以不要。但是size的作用并不仅仅是记录总数,它还有一个作用是使得last与first解耦,避免在一些代码中的一些麻烦。

    public class Code_01_Array_To_Stack_Queue {
    
        public static class ArrayStack{
            private Integer[] arr;
            private Integer   size;
    
            /**
             *  栈初始化
             * @param initSize 初始化数组容量
             */
            public ArrayStack(int initSize){
                if (initSize<0)
                    throw  new  IllegalArgumentException("参数不合理!");
                arr=new Integer[initSize];
                size=0;
            }
    
            /**
             * @Description: 返回栈顶元素
             * @return:  栈空 返回null 栈不空 返回栈顶元素
             * @date: 2019/4/23 10:12
             */
            public Integer peek(){
                if (size==0)
                    return null;
                Integer num = arr[size - 1];
                return num;
            }
    
            /**
             * @Description: 压栈操作
             * @param:    待压入元素
             * @date: 2019/4/23 10:15
             * @throws:  栈满时,抛出数组越界异常
             */
            public void push(int obj){
                if (size==arr.length)
                    throw new ArrayIndexOutOfBoundsException("栈满,无法压入!");
                arr[size++]=obj;
            }
    
            /**
             * @Description: 弹栈操作
             * @return:  返回栈顶元素 并数量减一
             * @date: 2019/4/23 10:19
             * @throws :  栈空时抛出数组越界异常
             */
            public Integer pop(){
                if (size==0)
                    throw new ArrayIndexOutOfBoundsException("栈空,无法弹栈!");
                return arr[--size];
            }
        }
    
        public static class ArrayQueue{
            private Integer[] arr;
            private Integer size;
            private Integer first;
            private Integer last;
    
            public ArrayQueue(int arrSize){
                if (arrSize==0)
                    throw new IllegalArgumentException("参数非法!");
                arr = new Integer[arrSize];
                size=0;
                first=last=0;
            }
            /**
             * @Description: 返回队首元素
            */
            public Integer peek(){
                if (size==0)
                    return null;
                return arr[first];
            }
    
            public void push(int obj){
                if (size==arr.length)
                    throw new ArrayIndexOutOfBoundsException("队满!");
                size++;
                arr[last]=obj;
                last= last==arr.length-1 ? 0 : last+1;
            }
    
            public Integer poll(){
                if (size==0)
                    throw  new ArrayIndexOutOfBoundsException("队空!");
                size--;
                int temp=first;
                first = first == arr.length-1 ? 0 : first+1;
                return  arr[temp];
            }
    
        }

     

     

    展开全文
  • LimitQueue固定长度的队列

    万次阅读 2016-06-03 18:32:02
    在开发过程中,有时会有这样的需求,一个固定长度的集合里,当收到新的数据时自动丢掉最旧的数据这样的队列结构。其实实现并不难,即一个队列结构的集合,在推送新数据时判断一下,当集合大小已经达到限制长度时自动...

    在开发过程中,有时会有这样的需求,一个固定长度的集合里,当收到新的数据时自动丢掉最旧的数据这样的队列结构。

    其实实现并不难,即一个队列结构的集合,在推送新数据时判断一下,当集合大小已经达到限制长度时自动丢掉最旧的数据。

    import java.util.LinkedList;
    
    public class LimitQueue<E>{
    	 
        private int limit; // 队列长度
            
        private LinkedList<E> queue = new LinkedList<E>();
            
        public LimitQueue(int limit){    
            this.limit = limit;    
        }    
        
        /**
         * 入列:当队列大小已满时,把队头的元素poll掉
         */
        public void offer(E e){    
            if(queue.size() >= limit){    
                queue.poll();    
            }  
            queue.offer(e);    
        }    
        
        public E get(int position) {
        	return queue.get(position);
        }
        
        public E getLast() {
        	return queue.getLast();
        }
        
        public E getFirst() {
        	return queue.getFirst();
        }
        
        public int getLimit() {
        	return limit;
        }
        
        public int size() {    
            return queue.size();    
        }    
        
    }

    其中,LinkedList已经实现了Queue接口,用起来比较方便



    展开全文
  • 上述通过数组实现的循环队列申请的空间是固定的,在使用的过程中无法随时进行更改,这里希望通过动态数组的方式来实现循环队列; 需要特殊考虑的是加倍技术,也就是在队列使用过程中的动态扩容,参照栈的实现,需要...
    • 上述通过数组实现的循环队列申请的空间是固定的,在使用的过程中无法随时进行更改,这里希望通过动态数组的方式来实现循环队列;
    • 需要特殊考虑的是加倍技术,也就是在队列使用过程中的动态扩容,参照栈的实现,需要使用malloc函数realloc函数来实现,但是初始队列里面可能已经包含元素,所以这里需要考虑的是将元素需要进行复制;
    • 原始队列为满表示队列为满的情况
    • 这里有一个位置是不填充元素的,首先将这个从下标0,也就是C的位置进行展开
      将上述的位置进行展开
    • 如果直接进行加倍并且进行元素的复制,得到的结果是
      这里写图片描述
    • 但是在保证队列里面元素相对位置不变的情况下,下面这种方式应该更好;
      这里写图片描述
    • 对于使用第二种方式进行复制的分析:

      • 1.如果front的初始位置为0,也就是说这个队列是一个满队列,这种情况下的复制就比较简单;
      if (start < 2)
      {
          cout << start << endl;
          copy(Queue + 1, Queue + 1 + MAX_SIZE - 1, newQueue);
      }
      • 2.否则对于数据的复制就分为两部分,首先是front部分的复制,然后是rear部分的复制;
      else
          {
              copy(Queue + start, Queue + start + MAX_SIZE, newQueue);
              copy(Queue, Queue + QueueInfo[0].rear + 1, newQueue + MAX_SIZE - start);
      }
    • 首先是队列初始化模块:
    typedef struct
    {
        int key;
    } elements;
    
    typedef struct
    {
        int rear;
        int front;
    } Info;
    
    int MAX_SIZE = 8;
    
    Info QueueInfo[1];
    
    void QueueInit( elements **Queue, Info *QueueInfo)
    {
        *Queue = (elements *)malloc(sizeof(elements) * MAX_SIZE);
        if (Queue == NULL)
        {
            fprintf(stderr, "Malloc error\n");
            exit(EXIT_FAILURE);
        }
        QueueInfo[0].rear = 0;
        QueueInfo[0].front = 0;
    }
    • 然后是判断队列满了之后的处理:
    elements *QueueFull(elements *Queue)
    {
        elements *newQueue;
        newQueue = (elements *)malloc(2 * MAX_SIZE * sizeof(elements));
        if (newQueue == NULL)
        {
            fprintf(stderr, "Malloc error\n");
            exit(EXIT_FAILURE);
        }
        int start = (QueueInfo[0].front + 1) % MAX_SIZE;
        if (start < 2)
        {
            cout << start << endl;
            copy(Queue + 1, Queue + 1 + MAX_SIZE - 1, newQueue);
        }
            else
            {
                copy(Queue + start, Queue + start + MAX_SIZE, newQueue);
                copy(Queue, Queue + QueueInfo[0].rear + 1, newQueue + MAX_SIZE - start);
            }
    
        QueueInfo[0].front = 2 * MAX_SIZE - 1;
        QueueInfo[0].rear = MAX_SIZE - 1;
        for (int i = 0; i < MAX_SIZE; i++)
        {
            cout << Queue[i].key << " ";
        }
        cout << endl;
        MAX_SIZE *= 2;
        free(Queue);
        Queue = newQueue;
        return Queue;
    
    }
    • 然后是添加元素,并可能调用上面的函数
    elements *AddQ(elements *Queue, int data)
    {
        QueueInfo[0].rear = (QueueInfo[0].rear + 1) % MAX_SIZE;
        if (QueueInfo[0].front == QueueInfo[0].rear)
            Queue = QueueFull(Queue);
        Queue[QueueInfo[0].rear].key = data;
        return Queue;
    }
    elements DeleteQ(elements *Queue)
    {
        if (QueueInfo[0].rear == QueueInfo[0].front)
        {
            fprintf(stderr, "The Queue is empty\n");
            exit(EXIT_FAILURE);
        }
        QueueInfo[0].front = (QueueInfo[0].front + 1) % MAX_SIZE;
        return Queue[QueueInfo[0].front];
    }
    • 然后是判断队列是否为满
    int  IsFull()
    {
        return (QueueInfo[0].rear + 1) % MAX_SIZE == QueueInfo[0].front ?
               true : false;
    }
    • 判断是否为空
    int IsEmpty(){
        return (QueueInfo[0].front%MAX_SIZE==QueueInfo[0].rear) ? 
            true : false;
    }

    上面的参数都进行了返回值的接收,因为是传值调用,因为这个是C++文件,也是可以改成引用传递的
    * 完整的代码

    #include <iostream>
    #include <cstdlib>
    #include <cstdio>
    
    #define true 1
    #define false 0
    using namespace std;
    typedef struct
    {
        int key;
    } elements;
    
    typedef struct
    {
        int rear;
        int front;
    } Info;
    
    int MAX_SIZE = 8;
    
    Info QueueInfo[1];
    
    
    elements *QueueFull(elements *Queue)
    {
        elements *newQueue;
        newQueue = (elements *)malloc(2 * MAX_SIZE * sizeof(elements));
        if (newQueue == NULL)
        {
            fprintf(stderr, "Malloc error\n");
            exit(EXIT_FAILURE);
        }
        int start = (QueueInfo[0].front + 1) % MAX_SIZE;
        if (start < 2)
        {
            cout << start << endl;
            copy(Queue + 1, Queue + 1 + MAX_SIZE - 1, newQueue);
        }
            else
            {
                copy(Queue + start, Queue + start + MAX_SIZE, newQueue);
                copy(Queue, Queue + QueueInfo[0].rear + 1, newQueue + MAX_SIZE - start);
            }
    
        QueueInfo[0].front = 2 * MAX_SIZE - 1;
        QueueInfo[0].rear = MAX_SIZE - 1;
        for (int i = 0; i < MAX_SIZE; i++)
        {
            cout << Queue[i].key << " ";
        }
        cout << endl;
        MAX_SIZE *= 2;
        free(Queue);
        Queue = newQueue;
        return Queue;
    
    }
    
    void QueueInit( elements **Queue, Info *QueueInfo)
    {
        *Queue = (elements *)malloc(sizeof(elements) * MAX_SIZE);
        if (Queue == NULL)
        {
            fprintf(stderr, "Malloc error\n");
            exit(EXIT_FAILURE);
        }
        QueueInfo[0].rear = 0;
        QueueInfo[0].front = 0;
    }
    
    elements *AddQ(elements *Queue, int data)
    {
        QueueInfo[0].rear = (QueueInfo[0].rear + 1) % MAX_SIZE;
        if (QueueInfo[0].front == QueueInfo[0].rear)
            Queue = QueueFull(Queue);
        Queue[QueueInfo[0].rear].key = data;
        return Queue;
    }
    elements DeleteQ(elements *Queue)
    {
        if (QueueInfo[0].rear == QueueInfo[0].front)
        {
            fprintf(stderr, "The Queue is empty\n");
            exit(EXIT_FAILURE);
        }
        QueueInfo[0].front = (QueueInfo[0].front + 1) % MAX_SIZE;
        return Queue[QueueInfo[0].front];
    }
    
    int  IsFull()
    {
        return (QueueInfo[0].rear + 1) % MAX_SIZE == QueueInfo[0].front ?
               true : false;
    }
    int IsEmpty(){
        return (QueueInfo[0].front%MAX_SIZE==QueueInfo[0].rear) ? 
            true : false;
    }
    int main()
    {
        elements *Queue = NULL;
    
        QueueInit(&Queue, QueueInfo);
        AddQ(Queue, 10);
        AddQ(Queue, 9);
        AddQ(Queue, 8);
        AddQ(Queue, 7);
        AddQ(Queue, 6);
        AddQ(Queue, 5);
        Queue = AddQ(Queue, 4);
        cout << IsFull() << endl;
        cout << IsEmpty() << endl;
    //  Queue = AddQ(Queue, 3);
    //  AddQ(Queue, 2);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  cout << "My Queue Delete " << endl;
    //  cout << "MAX_SIZE " << MAX_SIZE << endl;
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  DeleteQ(Queue);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    //  AddQ(Queue, 1);
    
        cout << "My Queue contains:\n" << endl;
        for (int i = 0; i < MAX_SIZE; i++)
        {
            cout << Queue[i].key << " ";
        }
    
    
        return 0;
    }
    展开全文
  • 数组实现固定大小的队列

    万次阅读 2021-02-05 14:46:15
    数组实现固定大小的队列前言1. java代码如下 前言 栈:正常用数组实现便可 队列:环形数组(两个指针相互追赶) 环形数组:初始化问题有点麻烦 新增一个size变量,解耦指针追赶 1. java代码如下 public static ...
  • 怎么理解无界队列和有界队列

    万次阅读 2018-11-01 14:53:11
    比如设定了固定大小的 LinkedBlockingQueue,又或者大小为 0,只是在生产者消费者中做中转用的 SynchronousQueue。 无界队列:指的是没有设置固定大小的队列。这些队列的特点是可以直接入列,直到溢出。当然现实...
  • 在多机测试环境下,采用fanout广播模式,会出现队列未被所需的机器消费到 因此每台机器需要使用自己的队列接受消息,所以尝试使用以下的方案: private statuc final String PREFIX = "test-"; private static final...
  • 使用数组实现固定长度的队列,原理简析:   代码实现:  package com.isea.brush; /** * 使用数组实现长度队列结构 * start:队首,拿取一个数,要存放的位置 * end: 队尾,新加一个元素,应该放在哪个...
  • 阻塞队列,有界队列,无界队列

    千次阅读 2021-03-12 16:01:58
    使用阻塞算法的队列可以用一个锁(入队出队用同一把锁)或两个锁(入队出队用不同的锁)等方式来实现。非阻塞的实现方式则可以使用自旋+CAS的方式来实现。 基本概念 阻塞队列与非阻塞队列 阻塞队列...
  • 实现一个固定长度的集合队列

    千次阅读 2018-08-27 10:47:46
    实现一个固定长度的集合队列 转载:https://blog.csdn.net/catoop/article/details/49737591 在开发中,有时候我们会遇到这样的需求: 对一个集合操作,提前为集合指定最大大小,在我们不断向集合中添加数据的...
  • 和队列是什么? 是概念!是逻辑结构!不是真是存在的!寄托载体不固定! 栈和队列的特征? 栈:先进后出,队列:先进先出 int、double……是数据类型 array、list、map都有各自固定的格式样式 而栈和队列可以是...
  • 循环队列和队列的比较
  • * 用数组结构实现大小固定队列和栈 */ public class Code_01_Array_To_Stack_Queue { public static class ArrayStack { private Integer[] arr; private Integer size; public ArraySt...
  • [Java] 固定队列的实现思路

    千次阅读 多人点赞 2014-10-20 15:53:43
    // 固定长度队列 // 可指定长度,使用方法与普通队列类似 // 当加入元素数量达到指定数量时将弹出元素 // 头部插入尾部弹出,尾部插入头部弹出 // 初始化最大长度为5 FixedList<Integer> list = new FixedList(5); ...
  • 一、固定大小数组实现栈 实现栈中的push(压栈)、pop(弹栈)、peek(返回栈顶第一个元素)。若压栈时将超过数组的最大容量,抛出异常信息,若弹栈时index = -1,同样抛出异常信息。 核心思想:使用index作为指针,当...
  • 本文档参考了纯粹的activemq java代码百度上的demo,很简洁的实现了动态消息队列的生成获取,但是没有自定义监听(当前项目不需要),本文档只有功能实现类 即业务层。若要调用推送 则需要自己根据需求编写。...
  • * 固定长度数组实现队列 */ public class ArrayQueue { private int[] data; private int start; private int end; private int size; public ArrayQueue(int capacity) { if (capacity &l...
  • Linux 工作队列和等待队列

    千次阅读 2018-03-22 10:17:08
    schedule_work调度执行一个具体的任务,执行的任务...输入参数:@ workqueue_struct:指定的workqueue指针@work_struct:具体任务对象指针Linux 工作队列和等待队列的区别等待队列在内核中有很多用途,尤其适合用于...
  • 使用数组实现固定长度的队列结构

    千次阅读 2018-04-03 11:15:53
    使用数组实现固定长度的队列结构,很多人coding时,都会使用两个变量startend作为指针,来表示队列的头尾,然后判断end大于start,start一直追赶end的这种方式实现,这其中有些边界条件判断来判断去,end到达...
  • 队列

    万次阅读 2013-01-16 08:12:28
    队列概述 队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。 –队尾...
  • springboot动态监听rabbitMq队列

    千次阅读 2020-07-15 14:16:12
    很多时候,要求mq队列能够配置,或者说相同的多个用户要求mq队列名称为用户名+固定的字符串,但是监听同一个方法,这个时候就需要用到动态监听。代码如下 @Autowired private AmqpAdmin amqpAdmin; @Autowired ...
  • 循环队列和队列(Java)

    万次阅读 2020-01-04 13:59:02
    队列:只允许在一端进行插入操作,而在另一端进行删除操作的线性表。 1.循环队列  队列的顺序储存结构:用数组存储队列,引入front指针指向队头元素,rear指针指向队尾元素的下一个位置,当front=rear时,为空...
  • 2022年考研数据结构_3 栈和队列

    万次阅读 2020-12-28 16:37:40
    和队列3.1 栈3.1.1 栈的定义3.1.2 栈的实现3.1.3 栈的应用(1)递归(2)四则运算表达式求解①中缀表达式转后缀表达式②后缀表达式的计算3.2 队列3.2.1 队列的定义3.2.2 队列的实现3.2.2 队列的应用3. 3 应用3.3.1 ...
  • C++用数组结构实现大小固定队列

    千次阅读 2019-05-05 21:57:41
    队列的先进先出的,需要一个数组4个变量size,end,start,length。size记录已经进来了多少个元素,end记录刚进来的元素应该放在哪个位置,start表示用户要求弹出的元素所在的位置。size的作用不止于此,它还是end与...
  • 队列——顺序队列

    千次阅读 2017-08-04 15:12:44
    队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队...
  • 多级队列:该算法将系统中的进程就绪队列从一个拆分为若干个,将不同类型或性质的进程固定分配在不同的就绪队列,不同的就绪队列采用不同的调度算法,一个就绪队列中的进程可以设置不同的优先级,不同的就绪队列本身...
  • 等待队列和工作队列

    千次阅读 2011-07-11 15:11:13
    对这2个容易混淆的队列做简单概念上的区别,至于怎么用,资料一大堆,不多说,等需要的时候再去找吧 等待队列在内核中有很多用途,尤其适合用于中断处理,进程同步及定时。我们在这里只说,进程经常必须等待某些...
  • 文章目录1、队列和栈2、有限队列2.1、SynchronousQueue:2.2、 ArrayBlockingQueue:3、 无限队列3.1、 LinkedBlockingQueue:3.2、 LinkedBlockingDeque3.3、PriorityBlockingQueue3.4、LinkedTransferQueue ...
  • 我们都知道栈和队列这两种最基本的数据结构,他们的特点分别为---栈:先进后出 队列:先进先出。那么,在java中如何利用数组来实现这两种数据结构的呢?一、实现栈:就是用一个数组来实现栈这个数据结构/** * 因为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 200,073
精华内容 80,029
关键字:

动态队列和固定队列