教大家怎样写队列？

最新推荐文章于 2024-07-28 19:16:57 发布
最新推荐文章于 2024-07-28 19:16:57 发布
阅读量2.7k 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/John_miko/article/details/82660065
版权

学习日志3
姓名：缪志超 日期：2018.9.12

今日学习任务
1、队列的顺序
2、链式存储
3、空对：队头队尾重合
4、队尾指针：指向最后一个元素的后一个
5、自定义函数来实现初始化，清空，输入，输出，删除，销毁等一系列操作

今日任务完成情况
1、按照课上老师的要求已经全部完成了所有的任务，并且实现了调试。
2、今天的代码开发量已经达到400多行。

今日开发中出现的问题
今天开发中出现的问题自己都能独立解决。

今日开发收获
1、学会了如何初始化，清空，输入，输出，删除，销毁等一系列操作
2、学会了如何队列的顺序存储

自我感觉
感觉不错，每天都能学到一些在学校学不到的知识，有成为程序员的潜力。

程序代码
下面我将我今天写的程序与大家共勉，如有错误还请大家指出，谢谢！
1、首先建一个文件名：queue.c

#include "queue.h"
#include <stdlib.h>
int InitQueue(Q *q)
{
    if(NULL == q)      //入参判断
    {
        return FAILURE;
    }
    //申请一块内存空间 ,并且让 data 指针指向 这块空间 
    q->data = (int *)malloc(sizeof(int)*MAXSIZE);
    if(NULL == q->data)        //返回值判断(如果申请失败 )
    {
        return FAILURE;
    }

    q->rear = q->front = 0;   //队头队尾 指针指向同一个
    return SUCCESS;
}

int EnterQueue(Q *q,int e)
{
    if(NULL == q)
    {
        return FAILURE;
    }
    if((q->rear + 1) % MAXSIZE == q->front)  // 队满
    {
        return FAILURE;
    }
    q->data[q->rear] = e;
    q->rear = (q->rear + 1) % MAXSIZE;

    return SUCCESS;
}

int DelQueue(Q *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }
    if(q->rear == q->front)       //空队
    {
        return FAILURE;
    }
    int e = q->data[q->front];
    q->front = (q->front + 1) % MAXSIZE;
    return e;
}

int LengthQueue(Q q)
{
    return (q.rear - q.front + MAXSIZE) % MAXSIZE;
}

int ClearQueue(Q *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }
    q->rear = q->front;
    return SUCCESS;
}


int DestroyQueue(Q *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }
    free(q->data);               //释放空间
    q->data = NULL;
    return SUCCESS;
}

再建一个文件名：main.c

#include <stdio.h>
#include "queue.h"

int main()
{
    int i, ret;
    Q queue;    //定义队列

    ret = InitQueue(&queue);
    if(SUCCESS == ret)
    {
        printf("Init Success!\n");
    }
    else
    {
        printf("Init Failure!\n");
    }
    for(i=0;i<10;i++)
    {
        ret = EnterQueue(&queue,i+1);
        if(ret == FAILURE)
        {
            printf("Enter Failure!\n");
        }
        else
        {
            printf("Enter %d Success!\n",i+1);
        }

    }
    for(i=0;i<5;i++)
    {
        ret = DelQueue(&queue);
        if(ret == FAILURE)
        {
            printf("Delete Failure!\n");
        }
        else
        {
            printf("Delete %d Success!\n",ret);
        }
    }

    ret = LengthQueue(queue);
    printf("length is %d\n",ret);

    ret = ClearQueue(&queue);
    if(ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("Clear Failure!\n"); 
    }

    ret = DestroyQueue(&queue);
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }
    return 0;
}

最后建一个文件名：queue.h

#ifndef QUEUE_H
#define QUEUE_H

#define MAXSIZE   10      //RONGLIANG
#define SUCCESS   1000
#define FAILURE   1001

struct queue
{
    int *data;        //指向队列的存储空间
    int front;       //队头指针
    int rear;        //队尾指针
};
typedef struct queue Q;

int InitQueue(Q *q);
int EnterQueue(Q *q,int e);
int DelQueue(Q *q);
int LengthQueue(Q q);
int ClearQueue(Q *q);
int DestroyQueue(Q *q);

#endif

输入命令：./a.out
调试结果 ：这里写图片描述

2、链式存储

首先建一个文件名：queue.h

#ifndef QUEUE_H
#define QUEUE_H

#define SUCCESS  1000
#define FAILURE  1001

struct node     //结点的信息
{
    int data;   //数据域
    struct node *next;  //指针域
};
typedef struct node Node;

struct queue          //队列的信息
{
    Node *front;     //队头指针
    Node *rear;      //队尾指针
};
typedef struct queue Q;

int InitQueue(Q **q);
int EnterQueue(Q *q,int e);
int DeletQueue(Q *q);
int LengthQueue(Q *q);
int ClearQueue(Q *q);
int EmptyQueue(Q *q);
int DestroyQueue(Q **q);
#endif

再建一个文件名：main.c

#include "queue.h"
#include <stdio.h>

int main()
{
    int i, ret;
    Q *queue;

    ret = InitQueue(&queue);
    if(ret == SUCCESS)
    {
        printf("Init Success!\n");
    }
    else
    {
        printf("Init Failure!\n");
    }

    for (i=0;i<10;i++)
    {
        ret = EnterQueue(queue,i+1);
        if(ret == SUCCESS)
        {
            printf("Enter %d Success!\n",i+1);
        }
        else
        {
            printf("Enter Failure!\n");
        }
    }

    for (i=0;i<6;i++)
    {
        ret = DeleteQueue(queue);
        if(ret == FAILURE)
        {
            printf("Delete Failure!\n");
        }
        else
        {
            printf("Delete %d Success!\n",ret);
        }

    }

    ret = LengthQueue(queue);
    printf("length is %d\n",ret);

    ret = ClearQueue(queue);
    if(ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("Clear Failure!\n");
    }

    ret = LengthQueue(queue);
    printf("length is %d\n",ret);

    ret = EmptyQueue(queue);
    if(SUCCESS == ret)
    {
        printf("queue is empty!\n");
    }
    else
    {
        printf("queue is not empty!\n");
    }

    ret = DestroyQueue(&queue);
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }
    return 0;
}

最后建一个文件名：queue.c

#include "queue.h"
#include <stdlib.h>

int InitQueue(Q **q)
{
    if (NULL == q)    //入参判断
    {
        return FAILURE;
    }

    (*q) = (Q *)malloc(sizeof(Q));  //gei dui lie xinxi shenqing kongjian   
    if(NULL == (*q))
    {
        return FAILURE;
    }

    Node *p = (Node *)malloc(sizeof(Node));//头结点申请空间
    if (NULL == p)
    {
        return FAILURE;
    }

    (*q)->front = (*q)->rear = p;//队头指针 队尾指针都指向头结点  

    return SUCCESS;
}

int EnterQueue(Q *q,int e)
{
    if(NULL == q)
    {
        return FAILURE;
    }

    Node *p = (Node *)malloc(sizeof(Node));
    if(NULL == p)
    {
        return FAILURE;
    }
    p->next = NULL;         //指针域
    p->data = e;           //数据域

    q->rear->next = p;
    q->rear = p;

    return SUCCESS;
}

int DeleteQueue(Q *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }
    if(q->rear == q->front)     //空队
    {
        return FAILURE;
    }

    Node *p = q->front->next;
    int e = p->data;
    q->front->next = p->next;
    free(p);

    if(q->rear == p)      //只剩一个结点的情况
    {
        q->rear = q->front;
    }
    return e;
}

int LengthQueue(Q *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }
    int length = 0;

    Node *p = q->front->next;
    while(p)         //while(p!=NULL)
    {
        length++;
        p = p->next;
    }
    return length;

}

int ClearQueue(Q *q)
{
    if(NULL == q)   //入参判断
    {
        return FAILURE;
    }

    Node *p = q->front->next;

    while(p)
    {
        q->front->next = p->next;
        free(p);                  //释放结点
        p = q->front->next;      //指向新的结点
    }

    q->rear = q->front;         //删完所有的结点，队尾指针指向开头

    return SUCCESS;
}

int EmptyQueue(Q *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }

    return (q->front == q->rear) ? SUCCESS : FAILURE;

}

int DestroyQueue(Q **q)
{
    if(NULL == q)
    {
        return FAILURE;
    }
    free((*q)->front);       //释放头结点
    free(*q);            //释放队列信息
    *q = NULL;

    return SUCCESS;
}

调试命令：./a.out
调试结果：这里写图片描述

John_miko
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
硬核！手写一个优先队列
bigsai
10-22 3100
前言 事情还要从一个故事讲起： 对于上面那只可爱的小狗狗不会，本篇即为该教程，首先，我要告诉这只可爱的小狗狗，这种问题你要使用的数据结构为优先队列，每次操作的时间复杂度为O(logn),而整个过程的时间复杂度为O(nlogn). 对于本片的设计与实现和堆排序可能有些相似，因为他们都借助堆来实现算法和数据结构，下面详细介绍优先队列的设计与实现。 堆 而堆就是一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树(完全)的数组对象。且总是满足以下规则： 堆总是一棵完全二叉树 每个节点总是大于(或小于)
【多线程】阻塞队列
程序猿教你打篮球的博客
06-01 4453
本期主要讲解： 1.认识阻塞队列和消息队列 2.生产者消费者模型 2.1认识生产者消费者模型 2.2阻塞队列实际中的实用 3.模拟实现一个阻塞队列
手写一个队列
皮皮狗
09-29 955
队列具有先进先出的特点，从队尾添加元素，从队首删除元素。对于队列，通常有两种实现方式：数组和链表。 1 利用数组来实现队列 利用两个指针font，rear分别指向队列的头部与尾部 为了能够有效利用数组空间，采用循环队列的方式去实现。 入队时，元素添加到rear指针处，然后real指针后移一位 出队时，删除并返回font指针所指元素，然后font指针后移一位 入队时，需要判断...
自己动手写一个简单的队列结构
凉拌糖醋鱼
07-10 1023
自己动手写一个简单的队列结构 队列(Queue)是除了数组和栈之外另一个比较简单的数据结构，它的特点跟栈有点区别，它的特点是“先进先出”，如果说栈是一个桶，那么队列就是一个管道，只能从一头添加元素，一头删除元素。 在这个例子中，我们的队列的底层是一个数组，通过两个指针来达到队列的效果，具体的原理如图。 通过两个指针来定义队列中的元素 当指针大于数组长度的时候，则重置为初始化值，从头指针到尾指针之间即是整个队列中的元素。 实现代码如下： package myQueue; public class MyQu
数据结构篇——队列的操作实现（队列、循环队列）！
最新发布
jjq20020211的博客
07-28 909
本文主要介绍了用数组和链表实现队列以及用数组实现循环队列的方法，并附有完整代码。
怎样写一个任务队列
mattkang
01-01 4895
之前在用celery的时候，遇到了worker卡住的bug，于是认真的看了相关文档和代码，了解celery实现的原理。 其实核心原理非常简单： 1. 发送任务到队列 2. 守护程序worker死循环不断从队列取任务并执行 至于怎么包装传递这个任务，实现思路类似函数传参，有传值、传引用。
写了一个很简单的消息队列
03-14
NULL 博文链接：https://zsp.iteye.com/blog/297957
自写一个队列
liu1251303815的博客
11-12 149
package com.stack; public class MyQueue { Node current; Node head; class Node{ Node next; String value; Node(String value){ this.value=value; } @Override public String toString() { .
教你php利用redis实现消息队列解析
pipujopijhpo的博客
04-07 892
php+redis消息队列是php+mysql性能不足时的一个中间间处理方案。通过这个中间的处理，保证的数据的可用性和准确性。用于服务器瞬间请求大，数据库压力大的情况。如并发量大导致的超卖、并发量大导致的数据重复情况。 流程：php接受请求和数据 -> php把数据写入redis队列中（入队） -> shell定时调用php读取队列数据写入mysql（出队） 实现代码： 入队：inqueue.php <?php $redis = new redis(); $redis->connec
教你写Android网络框架之Request Response类与请求队列
qq_44945094的博客
04-23 350
教你写Android网络框架之Request Response类与请求队列
c语言串口接收队列,队列的基本概念!从队列到串口缓冲区的实现
weixin_39876877的博客
05-19 1514
描述队列的概念在此之前，我们来回顾一下队列的基本概念：队列 (Queue)：是一种先进先出(First In First Out ,简称 FIFO)的线性表，只允许在一端插入(入队)，在另一端进行删除(出队)。队列的特点队列的常见两种形式普通队列在计算机中，每个信息都是存储在存储单元中的，比喻一下吧，上图的一些小正方形格子就是一个个存储单元，你可以理解为常见的数组，存放我们一个个的信息。当有大量数...
线程安全的队列写法
菜鸟の轨迹
10-02 744
首先，互斥量这种线程相关的内容是平台相关的，我假设你用的是windows平台开发。 其次，说明一下我的开发环境，vs2008，控制台程序，空的工程。 最后给你贴代码，分文件来看。 ===头文件QueueNode.h=== ===你需要的节点数据可能不是整数，只要将typedef int QUEUEDATA这一句的int换成你想要的类型即可，但要注意，这个类型必须实现赋值操作符重载，相等
优先队列写法
dgjm4087的博客
11-13 195
struct P { int x; bool operator < (const P &a) const { return x > a.x;//从小到大 } }; priority_queue<P> q; 　　 转载于:https://www.cnblogs.com/zero-...
循环队列的两种写法
RedGeek的博客
10-31 818
首先说一下主要思路：循环队列就是区别队列满和空的两个条件 因为是循环队列，空和满状态会是相同的！至于循环方式可以采用 一个空闲单位的方式（x+1）%MaxSize，这样符合计算机从0开始 计算的思维，+1就是补上计算机从0开始计算的那个数据。好了不 多说看下写法吧！ 下面展示一下第一种写法。 第一种写法，比较普遍，这就是空闲单位法 思路：留一个空间作为区别队列空和满的判定 #include <stdio.h> #define MaxSize 6 #define DataType int t
优先队列（目前遇到的各种写法）
nhl19961226的博客
03-28 1283
最近遇到了，就总结一下。 优先队列是按照其中的某一个参数，先输出最大（或者最小）的那一个。 优先队列的写法： priority_queue&amp;lt;int&amp;gt;q;//括号里可以填各种数据类型 priority_queue&amp;lt;node&amp;gt;q; priority_queue&amp;lt;int,vector&amp;lt;int&amp;gt;,greater&amp;lt;int&
c语言队列程序怎么写,[原创]非常漂亮的队列演示程序(C语言版)
weixin_31588005的博客
05-22 121
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#defineMAX10/*规定队列中可存放的字节数,[1~254]*/typedefenum{FALSE,TRUE}boolean;booleanSaveNumber(unsignedchar*q,unsignedchar*front,unsignedchar*rear,unsignedchar*ch);booleanDe...
队列的用法
lowB程序员
09-23 1194
队列本质上是一种特殊的线性表，它是在一端（队首）进行删除操作，而在另外一端（队尾）进行插入操作，它要遵循先进先出的规则。 队首(front) ：允许进行删除的一端称为队首。 队尾(rear) ：允许进行插入的一端称为队尾。 队列有两种数据存储方式：1、顺序存储结构（静态队列，用数组实现，地址是连续的）。2、链式存储结构（动态队列，用动态链表实现，地址是不连续的）。 一、队列的基本操作：
c语言 队列方法的编写
weixin_44269491的博客
08-17 700
队列的特点是先进先出，就像排队买票一样，就结合排队买票的特点编写实现队列的方法。 首先队列的实现需要三个元素： （1）排队通道，通常用数组来表示； （2）队首的标记，用来出队列使用； （3）队尾的标记，用来加入元素使用； 完成上述工作需要用结构体定义队列的三个初始属性： 按照队列的特点需要完成一下几点： （1）队列初始化，由于定义的结构体里只是定义了属性，而没有定义属行一开始该是多少所以需要初始化一下； 将首位标记均初始化为0 （2）进队列：进队列需要将新的元素放进data[]数组中，并且将尾部标记向后移
用链表写队列
FunkyFrog821951259的博客
11-14 382
#include #include #include struct node { int num; struct node*next; }; typedef struct node Node; struct queue_link { Node*top; Node*buttom; }; typedef struct queue_link Queue; void create_queue(Q
什么是优先队列？如何实现优先队列？
11-25
优先队列是一种抽象数据类型，其中每个元素都有一个优先级。在优先队列中，具有高优先级的元素先出队，而具有相同优先级的元素按照它们在队列中的顺序出队。优先队列可以用于许多应用程序，例如任务调度和数据压缩。 实现优先队列的一种常见方法是使用堆。堆是一种树形数据结构，其中每个节点都比其子节点具有更高或更低的优先级。在优先队列中，堆通常是一个二叉堆，其中每个节点都比其两个子节点具有更高或更低的优先级。这使得在堆中查找最高或最低优先级元素的时间复杂度为O(1)，并且在插入和删除元素时的时间复杂度为O(log n)。 以下是一个使用Python heapq模块实现优先队列的示例： ```python import heapq class PriorityQueue: def __init__(self): self._queue = [] self._index = 0 def push(self, item, priority): heapq.heappush(self._queue, (-priority, self._index, item)) self._index += 1 def pop(self): return heapq.heappop(self._queue)[-1] ``` 在这个示例中，我们使用Python的heapq模块来实现优先队列。我们定义了一个PriorityQueue类，其中push方法用于将元素插入队列中，并根据其优先级进行排序。pop方法用于从队列中删除并返回具有最高优先级的元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值