精华内容
下载资源
问答
  • 主要介绍了springboot实现rabbitmq的队列初始化和绑定,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • mq初始队列

    2018-05-16 14:39:33
    mq连接时初始化的动作,用于java开发的简单例子。。。。
  • 队列题目:初始队列+入队列+出队列+销毁队列
  • //初始队列 LQueue *init_LinkQueue() { LinkQueue *head; LQueue *Q; Q = (LQueue *)malloc(sizeof(LQueue)); head = (LinkQueue *)malloc(sizeof(LinkQueue)); if(0 == Q || 0 == head){ return Q; } head -> ...

    //头文件和机构体

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef int elemtype;
    //链表节点
    typedef struct LinkQueuenode
    {
        elemtype data;
        struct LinkQueuenode *next;
    }LinkQueue;
    //指向链表的头结点的节点
    typedef struct LQueue
    {
        LinkQueue *front;
        LinkQueue *rear;
    }LQueue;
    

    //初始化队列

    LQueue *init_LinkQueue()
    {
        LinkQueue *head;
        LQueue *Q;
        Q = (LQueue *)malloc(sizeof(LQueue));
        head = (LinkQueue *)malloc(sizeof(LinkQueue));
        if(0 == Q || 0 == head){
            return Q;
        }
        head -> next = NULL;
        Q -> front = head;
        Q -> rear = head;
        head -> data = 0;
        return Q;
    }
    

    //入队

    void enter_LinkQueue(LQueue *Q,elemtype x)
    {
        LinkQueue *p;
        p = (LinkQueue *)malloc(sizeof(LinkQueue));
        if(0 == p){
            return;
        }
        p -> data = x;
        p -> next = NULL;
        Q -> front -> data ++;//记录节点的个数
        Q -> rear -> next = p;
        Q -> rear = p;
        return;
    }
    

    //出队

    void delete_LinkQueue(LQueue *Q,elemtype *x)
    {
        LinkQueue *node;
        node = Q -> front -> next;//首结点
        if(Q -> front == Q -> rear){
            return;
        }
    
        *x = node -> data;
        Q -> front -> next  = node -> next;
        if(node == Q -> rear){
            Q -> rear = Q -> front;
        }
        free(node);
        Q -> front -> data --;
        return;
    }
    

    //输出

    void print(LQueue *Q)
    {
        elemtype *x;
        int k;
        x = &k;
        while(Q -> front != Q -> rear){
            delete_LinkQueue(Q,x);
            printf("%d ",*x);
        }
    }
    

    下面的完整代码

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef int elemtype;
    typedef struct LinkQueuenode
    {
        elemtype data;
        struct LinkQueuenode *next;
    }LinkQueue;
    typedef struct LQueue
    {
        LinkQueue *front;
        LinkQueue *rear;
    }LQueue;
    
    //初始化队列
    LQueue *init_LinkQueue()
    {
        LinkQueue *head;
        LQueue *Q;
        Q = (LQueue *)malloc(sizeof(LQueue));
        head = (LinkQueue *)malloc(sizeof(LinkQueue));
        if(0 == Q || 0 == head){
            return Q;
        }
        head -> next = NULL;
        Q -> front = head;
        Q -> rear = head;
        head -> data = 0;
        return Q;
    }
    //入队列
    void enter_LinkQueue(LQueue *Q,elemtype x)
    {
        LinkQueue *p;
        p = (LinkQueue *)malloc(sizeof(LinkQueue));
        if(0 == p){
            return;
        }
        p -> data = x;
        p -> next = NULL;
        Q -> front -> data ++;//记录节点的个数
        Q -> rear -> next = p;
        Q -> rear = p;
        return;
    }
    
    //出队列
    void delete_LinkQueue(LQueue *Q,elemtype *x)
    {
        LinkQueue *node;
        node = Q -> front -> next;//首结点
        if(Q -> front == Q -> rear){
            return;
        }
    
        *x = node -> data;
        Q -> front -> next  = node -> next;
        if(node == Q -> rear){
            Q -> rear = Q -> front;
        }
        free(node);
        Q -> front -> data --;
        return;
    }
    
    //输出
    void print(LQueue *Q)
    {
        elemtype *x;
        int k;
        x = &k;
        printf("出队结果为:");
        while(Q -> front != Q -> rear){
            delete_LinkQueue(Q,x);
            printf("%d ",*x);
        }
        printf("\n");
    }
    
    int main()
    {
        LQueue *Q;
        elemtype x;
        Q = init_LinkQueue();
        printf("请输入您想输入的数据(输入-100结束):");
        while(x != -100){
            scanf("%d",&x);
            if(x == -100){
                break;
            }
            enter_LinkQueue(Q,x);
        }
        printf("\n");
        print(Q);
    }
    

    运行结果
    在这里插入图片描述

    小伙伴对代码有疑问的可以在下面评论或者私聊我哦,
    对您有帮助,点个赞支持一下吧!

    展开全文
  • C语言_初始队列+入队列+出队列+销毁队列
  • 针对视频初始缓冲队列长度难以准确测量的问题,对非加密的优酷和加密的YouTube两类视频平台进行研究,提出了视频初始缓冲队列长度测量方法。通过识别分析视频流量特征,关联流量行为与播放状态,构建视频指纹库,...
  • 实现循环队列,适合数据结构的小白~
  • 队列初始化出队入队

    千次阅读 2020-03-19 11:30:54
    //初始化 Status InitQueue(LinkQueue &Q) { Q.front = Q.rear = new QNode; Q.front->next = NULL; return OK; } //入队 Status EnQueue(LinkQueue &Q,QElemType e) { QueuePtr p; p = new QNode; p->data =...

    运行截图:
    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    #define OK 1
    #define ERROR  0;
    typedef int Status;
    typedef int QElemType;
    typedef struct QNode
    {
    	QElemType data;
    	struct QNode *next;
    }QNode, *QueuePtr;
    typedef struct
    {
    	QueuePtr front;
    	QueuePtr rear;
    }LinkQueue;
    //初始化
    Status InitQueue(LinkQueue &Q)
    {
    	Q.front = Q.rear = new QNode;
    	Q.front->next = NULL;
    	return OK;
    }
    //入队
    Status EnQueue(LinkQueue &Q,QElemType e)
    {
    	QueuePtr p;
    	p = new QNode;
    	p->data = e;
    	p->next  = NULL;
    	Q.rear->next = p;
    	Q.rear = p;
    	return OK;
    }
    //出队
    Status DeQueue(LinkQueue &Q,QElemType &e)
    {
    	if(Q.rear == Q.front)
    		return ERROR ;
    	QueuePtr p;
    	p = Q.front ->next;
    	e = p->data;
    	Q.front ->next  = p->next;
    	if(Q.rear == p) Q.rear  = Q.front;
    	delete p;
    	return OK;
    }
    int main()
    {
    	LinkQueue Q;
    	InitQueue(Q);
    	int e = 1;
    	printf("入队(以00结束):");
    	while (e)
    	{
    		scanf("%d",&e);
    		if (e == 00)
    			break;
    		 EnQueue(Q,e);
    	}
    	printf("出队:");
    	while(Q.rear != Q.front)
    	{
    	DeQueue(Q,e);
    	printf("%5d",e);
    	}
    	printf("\n");
    	return 0;
    }
    
    展开全文
  • 队列的结构体: typedef QNode* QDataType; // 链式结构:表示队列 typedef struct QNode { struct QNode* pNext; QDataType data; }QNode; // 队列的结构 typedef struct Queue { QNode *head; // 链表...

    队列的结构体:

    
    typedef QNode* QDataType;
    
    // 链式结构:表示队列 
    typedef struct QNode
    {
    	struct QNode* pNext;
    	QDataType data;
    }QNode;
    
    // 队列的结构 
    typedef struct Queue
    {
    	QNode *head;		// 链表的第一个结点
    	QNode *last;		// 链表的最后一个结点
    }Queue;

    函数功能汇总:

    // 初始化队列 
    void QueueInit(Queue* q); 
    
    // 队尾入队列 
    void QueuePush(Queue* q, QDataType data); 
    
    // 队头出队列 
    void QueuePop(Queue* q); 
    
    // 获取队列头部元素 
    QDataType QueueFront(Queue* q); 
    
    // 获取队列队尾元素 
    QDataType QueueBack(Queue* q); 
    
    // 获取队列中有效元素个数 
    int QueueSize(Queue* q); 
    
    // 检测队列是否为空,如果为空返回非零结果,如果非空返回0 
    int QueueEmpty(Queue* q); 
    
    // 销毁队列 
    void QueueDestroy(Queue* q); 

    初始化队列:

    //初始化队列
    void QueueInit(Queue* q)
    {
    	q->head = q->last = NULL;
    }

     队尾入队列(入队列):

    // 队尾入队列   //入队列
    void QueuePush(Queue* q, QDataType data)
    {
    	QNode *node = (QNode *)malloc(sizeof(QNode));
    	node->data = data;
    	node->pNext = NULL;
    	if (q->head == NULL)
    	{
    		q->head = node;
    		q->last = node;
    	}
    	else
    	{
    		q->last->pNext = node;
    		q->last = node;
    	}
    }
    

    队头出队列(出队列):

    // 队头出队列   //出队列
    void QueuePop(Queue* q)
    {
    	QNode* node = (QNode*)malloc(sizeof(QNode));
    	node = q->head;
    	free(q->head);
    	q->head = node;
    
    	// last 有没有可能也需要变更
    	if (q->head == NULL) {
    		q->last = NULL;
    	}
    }
    

    获取队列头部元素 :

    // 获取队列头部元素 
    QDataType QueueFront(Queue* q)
    {
    	return q->head->data;
    }

    获取队尾元素:

    // 获取队列队尾元素 
    QDataType QueueBack(Queue* q)
    {
    	return q->last->data;
    }

    获取队列中有效元素个数 :

    // 获取队列中有效元素个数 
    int QueueSize(Queue* q)
    {
    	int size;
    	for (QNode* c=q->head ; c !=NULL; c=c->pNext)
    	{
    		size++;
    	}
    	return size;
    }
    

    判空:

    // 检测队列是否为空,如果为空返回非零结果,如果非空返回0 
    int QueueEmpty(Queue* q)
    {
    	if (q->head == NULL)
    		return 1;
    	else
    		return 0;
    }

    销毁队列:

    // 销毁队列 
    void QueueDestroy(Queue* q)
    {
    	QNode* node;
    	for ( node =q->head; node !=NULL; node=node->pNext)
    	{
    		free(node);
    	}
    	q->head = NULL;
    	q->last = NULL;
    }

     

    展开全文
  • 主要介绍了python 队列基本定义与使用方法,结合实例形式分析了Python队列的定义、初始化、赋值、判断等相关操作技巧,需要的朋友可以参考下
  • 链式队列需要有队头指针和队尾指针才能唯一确定一个队列,头指针一般指向头结点,尾指针指向最后一个元素结点。空的队列就是队头指针和队尾指针都指向了头结点。在可以确地长度最大值时采用循环队列,无法估计长度的...

    链式队列需要有队头指针和队尾指针才能唯一确定一个队列,头指针一般指向头结点,尾指针指向最后一个元素结点。空的队列就是队头指针和队尾指针都指向了头结点。在可以确地长度最大值时采用循环队列,无法估计长度的时候用链式队列。

    结构定义

    typedef int QElemType;
    typedef struct QNode{
        QElemType data;
        struct QNode *next;
    }QNode,*QueuePtr;
    typedef struct
    {
        //对头和队尾指针
        QueuePtr front,rear;
    }LinkQueue;
    操作函数

    //初始化
    Status InitQueue(LinkQueue *Q){
        Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
        if(!Q->front) exit(OVERFLOW);
        Q->front->next = NULL;
        return OK;
    }
    
    //销毁队列
    Status DestroyQueue(LinkQueue *Q){
        while(Q->front){
            Q->rear = Q->front->next;
            free(Q->front);
            Q->front = Q->rear;
        }
        return OK;
    }
    
    //插入元素e到队尾
    Status EnQueue(LinkQueue *Q,QElemType e){
        QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
        if(!p) exit(OVERFLOW);
        p->data = e;
        p->next = NULL;
        Q->rear->next = p;
        Q->rear = p;
        return OK;
    }
    
    //出队列
    Status DeQueue(LinkQueue *Q,QElemType *e){
        if(Q->front == Q->rear) return ERROR;
        QueuePtr p = Q->front->next;
        *e = p->data;
        Q->front->next = p->next;
        //当队列中最后一个元素被删除了,队列尾指针也丢失了
        //因此需要对队尾指针重新赋值
        if(Q->rear == p) Q->rear = Q->front;
        free(p);
        return OK;
    }
    
    Status OutputQueue(LinkQueue Q){
        QueuePtr  p = Q.front->next;
        while(p){
            printf("元素的值是:%d\n",p->data);
            p = p->next;
        }
    }
    Main函数

    int main() {
    
        LinkQueue Q;
        InitQueue(&Q);
        int x,i;
        QElemType e;
        printf("请输入要入队列几个数:");
        scanf("%d",&x);
        for (i = 0; i < x; ++i) {
            printf("请输入要入队列元素值:");
            scanf("%d",&e);
            EnQueue(&Q,e);
        }
    
        DeQueue(&Q,&e);
        DeQueue(&Q,&e);
    
        OutputQueue(Q);
    
        return 0;
    }




    展开全文
  • #include <stdio.h> #include <stdlib.h> #define MAX 100 ...//顺序队列初始化 SeqQueue SeqQueueInit() { SeqQueue Q; //队头和队尾相等即为空队列 Q.front = Q.rear = 0; return Q; }
  • 循环队列: 入队时:rear = (rear+1)%数组的长度 出队时:front = (front+1)%数组的长度 队列为空时:rear == front 队列满时:(rear+1)%数组的长度 == front */ typedef struct Queue { int * ...
  • java中栈、队列、双端队列初始

    千次阅读 2020-10-03 16:03:40
    队列初始化 Deque<Integer> queue= new LinkedList<Integer>(); 插入队头/队尾元素:addFirst()、addLast() 删除队头/队尾元素:removeFirst()、removeLast() 获取队头/队尾元素:g.
  • 4, 【2019统考真题】请设计一个队列,要求满足: 初始时队列为空; ②入队时,允许增加队列占用空间; ③出队后,出队元素所占用的空间可重复使用,即整个队列所占用的空间只增不减;④入队操作和出队操作的时间复杂度始终...
  • c++ stl队列初始化Here, we have to declare, initialize and access a vector in C++ STL. 在这里,我们必须声明,初始化和访问C ++ STL中的向量。 向量声明 (Vector declaration) Syntax: 句法: vector<...
  • 队列初始化 判断队列是否为空 入队列队列 等等操作先上个示意图(图片来源 严蔚敏版数据结构) 可能更好理解 1 // 2 // main.cpp 3 // WWLinkQueueBasic 4 // 5 // Created by Live on 2017/8/22. 6 ...
  • //初始化循环队列 Status InitQueue(SqQueue *Q){ Q->front = 0; Q->rear = 0; return OK; } //求循环队列的长度 int QueueLength(SqQueue Q){ return (Q.rear-Q.front+MAXSIZE)%MAXSIZE; } //若队列未满,则...
  • * 支持初始队列,即在init()前进行发布。 * * 调用init()时才真正启动线程开始处理 * 系统退出自动清理资源. * * @author JIM * * @param <D> 消息类 * @param <E> 消息包装类 * @param <H> ...
  • 2、使用带参构造初始队列 3、成员方法定义入队出队操作 public class Queue { int maxSize;//队列最大容量 int rear;//模拟队列头指针 int front;//模拟队列尾指针 Object[] array; //使用数组模拟队列 /...
  • springboot rabbitMq队列初始化方法有多种方式这里列出4种 1.使用注解@Bean与类Queue单一队列初始化 如下 /** *若队列不存在创建队列第二个参数为是否持久化 * *@return */ @Bean publicQueueQueue1(){ ...
  • 文章目录队列队列的存储队列的基本操作顺序存储下队列的基本操作实现循环队列链式存储下队列的基本操作实现 队列队列(Queue)简称队,也是一种操作受限的线性表,只允许在表的一端进行插入而在表的另一端进行...
  • 主要介绍了循环队列详解及队列的顺序表示和实现的相关资料,需要的朋友可以参考下
  • 实现循环队列初始化、进队出队、打印输出所有队列元素、获取队头元素,dos窗口输出。一般队列可在此基础上修改即可!
  • //静态循环队列(用数组) //用模%来实现队列的循环 //约定head指针指向实际头元素的位置 //约定rear指针指向实际尾元素的后一个位置 //约定当数组只剩一个空位是,默认此时数组已满(为了避免区别队满和队空的判断...
  • 初始队列初始化一个size长度的队列队列的值都为0 判断队列是否已满:队列满,不可插入队列 判断队列是否为空:队列空,没有数据可以出队 入队:将数据item插入队列 出队:将对头元素从队列中删除并返回的值 ...
  • 顺序队列初始

    千次阅读 2016-04-09 16:50:20
    //注意得到队列长度公式(rear-front+Max)%Max return n; } template bool SeqQueue<T>::IsEmpty() { if(rear==front_) return true; return false; } template bool SeqQueue<T>::IsFull() { if((rear+1)%...
  • 循环队列初始化到清空

    千次阅读 2018-08-08 21:22:06
    //初始化空队 return SUCCESS; } int EmptyQueue(Queue q) { return (q.front == q.rear) ? TRUE : FALSE; } int EnterQueue(Queue *q, int e) { if (NULL == q) { return FAILURE; } if ((q->rear + 1...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 490,753
精华内容 196,301
关键字:

初始队列