精华内容
下载资源
问答
  • 2022-03-25 01:25:37

    队列是一种基本的数据结构具有FIFO的特性(先进先出),下面是数组实现队列

    一.静态数组实现队列

    实现队列中需要定义的变量,头指针front,数组的大小maxsize,数组array,尾指针rear

    在java中的定义如下

    public class ArrayQueen {
        //数组最大长度
        private int maxsize;
        //队列头指针
        private int front;
        //队列尾指针
        private int rear;
        //数组实现队列
        private int[] arr;
    }

    初始化时,头指针和尾指针相等,即 front = rear = -1,在java中可以在类的构造方法中完成变量的初始化。

    //用构造方法实现队列的初始化
        public ArrayQueen(int maxsize){
            this.maxsize = maxsize;
            front = -1 ;
            rear = -1 ;
            this.arr = new int[maxsize];
        }

    接下来,为了方便操作可以让头指针指向第一个元素的前一个位置,尾指针指向最后一个元素

    判断队列为空的条件是:尾指针等于头指针即rear = = front

    判断队列为满的条件是:尾指针指向数组最大长度减一,即rear == maxsize - 1(这里的数组是从下标为零开始的)

    增加元素时:尾指针后移一位,再将数值赋给尾指针指向的位置,即arr[++rear] = 数值

    删除元素时:头指针后移一位,再返回头指针指向的元素,即 return arr[++front];

    ps:我这里的操作都是基于头指针指向第一个元素的前一个位置,尾指针指向最后一个元素的情况

    在java中的实现如下

    //判断队列是否为满
        public boolean isFull(){
            if (rear == (maxsize - 1)){
                return true;
            }
            return false;
        }
        //判断队列是否为空
        public boolean isEmpty(){
            if (rear == front){
                return true;
            }
            return  false;
        }
        //先判断队列是否为满,再添加元素
        public void add(int num){
            if (isFull()){
              System.out.println("队列为满,不可添加");
              return;
            }
            arr[++rear] = num ;
        }
        //先判断队列是否为空,在进行取数字
        public int getNum(){
            if (isEmpty()){
                throw new RuntimeException("队列为空,不可取数字");
            }
            return arr[++front];
        }
        //取头部数字
        public void queryHead(){
            if (isEmpty()){
                throw new RuntimeException("队列为空,不可取数字");
            }
            System.out.println("头部的数字为:" + arr[++front]);
        }
        //查询队列中的元素
        public void query(){
            System.out.print("队列中的元素有:");
            for (int i = 0; i < arr.length; i++) {
                System.out.print("\t" + arr[i]);
            }
        }

    二.静态数组实现循环队列

    由于静态数组的局限性,无法对数组的空间完美利用,所以就出现了循环队列,实现循环队列的方法很多,我这里写的是牺牲数组中的一个存储空间实现循环队列的方法

    循环队列同样是用静态数组实现的,只不过在其中加入了取余操作,使其成为了一个环状,在其中同样需要定义数组,数组的最大长度,头指针和尾指针,只不过初始化时头指针与尾指针都指向了数组0的位置,即 rear = front = 0;

    接下来的操作都是基于头指针指向数组的第一个元素位置,而尾指针指向数组的最后一个元素的后一个位置,并在数组中空出一个位置且这个位置不可添加元素,如图所示

     队列中的元素个数:(rear + maxsize - front)% maxsize

    判断队列为满:(rear + 1)% maxsize == front

    判断队列为空: rear == front

    增加元素:将需要添加的数值赋给rear指针所指的位置,然后(rear+1)即,arr[rear] = 数值;

                                                                                                                               rear++;

     删除元素:将front指针所指的元素赋值给一个变量,然后(front+1),之后在返回这个变量

                   即:  num = rear[front];

                            front++;

                           return num;

    更多相关内容
  • 1实验目的掌握循环队列的基本操作并对其进行简单应用 2实验内容 假设循环队列的最大长度为7现在依次将以下数据入队列{753924}接着进行3次出队列的操作将1518这两个数据入队列最后从对头到队尾依次输出队列中的元素...
  • 循环队列

    2021-07-15 02:42:30
    为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的...中文名循环队列外文名Circular Queue领域实现方式有关术语特点大小固定循环队列简介编辑语音循环队列就是将队列存储空间的最后...

    为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。

    中文名

    循环队列

    外文名

    Circular Queue

    领    域实现方式

    有关术语

    特    点

    大小固定

    循环队列简介

    编辑

    语音

    循环队列就是将队列存储空间的最后一个位置绕到第一个位置,形成逻辑上的环状空间,供队列循环使用。在循环队列结构中,当存储空间的最后一个位置已被使用而再要进入队运算时,只需要存储空间的第一个位置空闲,便可将元素加入到第一个位置,即将存储空间的第一个位置作为队尾。[1]

    循环队列可以更简单防止伪溢出的发生,但队列大小是固定的。

    在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件是front=rear,而队列判满的条件是front=(rear+1)%MaxSize。[2]

    循环队列基本操作

    编辑

    语音

    // 队列的顺序存储结构(循环队列)

    #define MAX_QSIZE 5 // 最大队列长度+1

    typedef struct {

    int *base; // 初始化的动态分配存储空间

    int front; // 头指针,若队列不空,指向队列头元素

    int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置

    } SqQueue;

    // 构造一个空队列Q

    SqQueue* Q_Init() {

    SqQueue *Q = (SqQueue*)malloc(sizeof(SqQueue));

    // 存储分配失败

    if (!Q){

    exit(OVERFLOW);

    }

    Q->base = (int *)malloc(MAX_QSIZE * sizeof(int));

    // 存储分配失败

    if (!Q->base){

    exit(OVERFLOW);

    }

    Q->front = Q->rear = 0;

    return Q;

    }

    // 销毁队列Q,Q不再存在

    void Q_Destroy(SqQueue *Q) {

    if (Q->base)

    free(Q->base);

    Q->base = NULL;

    Q->front = Q->rear = 0;

    free(Q);

    }

    // 将Q清为空队列

    void Q_Clear(SqQueue *Q) {

    Q->front = Q->rear = 0;

    }

    // 若队列Q为空队列,则返回1;否则返回-1

    int Q_Empty(SqQueue Q) {

    if (Q.front == Q.rear) // 队列空的标志

    return 1;

    else

    return -1;

    }

    // 返回Q的元素个数,即队列的长度

    int Q_Length(SqQueue Q) {

    return (Q.rear - Q.front + MAX_QSIZE) % MAX_QSIZE;

    }

    // 若队列不空,则用e返回Q的队头元素,并返回OK;否则返回ERROR

    int Q_GetHead(SqQueue Q, int &e) {

    if (Q.front == Q.rear) // 队列空

    return -1;

    e = Q.base[Q.front];

    return 1;

    }

    // 打印队列中的内容

    void Q_Print(SqQueue Q) {

    int p = Q.front;

    while (Q.rear != p) {

    cout <

    p = (p + 1) % MAX_QSIZE;

    }

    }

    // 插入元素e为Q的新的队尾元素

    int Q_Put(SqQueue *Q, int e) {

    if ((Q->rear + 1) % MAX_QSIZE == Q->front) // 队列满

    return -1;

    Q->base[Q->rear] = e;

    Q->rear = (Q->rear + 1) % MAX_QSIZE;

    return 1;

    }

    // 若队列不空,则删除Q的队头元素,用e返回其值,并返回1;否则返回-1

    int Q_Poll(SqQueue *Q, int &e) {

    if (Q->front == Q->rear) // 队列空

    return -1;

    e = Q->base[Q->front];

    Q->front = (Q->front + 1) % MAX_QSIZE;

    return 1;

    }

    循环队列条件处理

    编辑

    语音

    循环队列中,由于入队时尾指针向前追赶头指针;出队时头指针向前追赶尾指针,造成队空和队满时头尾指针均相等。因此,无法通过条件front==rear来判别队列是"空"还是"满"。

    解决这个问题的方法至少有两种:

    ① 另设一布尔变量以区别队列的空和满;

    ②另一种方式就是数据结构常用的: 队满时:(rear+1)%n==front,n为队列长度(所用数组大小),由于rear,front均为所用空间的指针,循环只是逻辑上的循环,所以需要求余运算。如图1所示情况,队已满,但是rear(5)+1=6!=front(0),对空间长度求余,作用就在此6%6=0=front(0)。

    ae24e1d58d6514b9f190b083c417fd7e.png

    图1

    类型定义采用环状模型来实现队列,各数据成员的意义如下:

    front指定队首位置,删除一个元素就将front顺时针移动一位;

    rear指向元素要插入的位置,插入一个元素就将rear顺时针移动一位;

    count存放队列中元素的个数,当count等于MaxQSize时,不可再向队列中插入元素。

    循环队列队列

    编辑

    语音

    数据结构分为线性结构和非线性结构,队列和线性表都是线性结构。线性表是由n 个数据元素组成的有限序列,该序列有惟一的“第一个”和惟一的“最后一个”数据元素;除了 “第一个”和“最后一个”之外,队列中的每个数据元素都只有一个直接前驱和一个直接后继。线性表的插入和删除操作可以在表中任意位置进行。队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

    队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队,从队列中删除一个队列元素称为出队。因为队列只允许在一端插入,在另一端删除,所以只有最早进入队列的元素才能最先从队列中删除,故队列又称为先进先出(FIFO—first in first out)线性表。

    词条图册

    更多图册

    参考资料

    1.

    杨非.C语言程序设计应试辅导: 二级:清华大学出版社,2006

    展开全文
  • C语言实现循环队列

    万次阅读 多人点赞 2020-06-24 15:58:46
    详解循环队列的巧妙之处

    顺序队列的假溢出

    顺序队列假溢出

    1️⃣:初始化空队列,q -> front = q -> rear = 0

    2️⃣:入队a1、a2、a3,q -> front = 0, q -> rear = 3

    3️⃣:出队a1、a2,q -> front = 2, q -> rear = 3

    4️⃣:入队a4、a5、a6,q -> front = 2, q -> rear = 6

    执行 4️⃣ 操作后队列的"尾指针"已经超出对队列的最大范围了,之后无法再进行入队操作,而队列实际空间并未占满,就造成了假溢出。


    解决上溢的方法

    1、将队中元素依次向队头方向移动。

    • 缺点:浪费时间。每移动一次, 队中元素都要移动

    2、将队列空间设想成一个循环的表,即分配给队列的 m 个存储单元可以循环使用,当 rearMAXSIZE 时,若队列的开始端空着,又可从头使用空着的空间。当 frontMAXSIZE 时也是一样。

    我们采用第2种方法

    5️⃣:入队a7,q -> front = 2, q -> rear = 0

    解决顺序队列假溢出


    引入循环队列

    base[0] 接在 base[MAXSIZE -1] 之后,若 rear + 1 == M,则令 rear = 0

    实现方法: 利用 模(mod,C语言中: %)运算

    插入元素:

    // 队尾入队
    q -> base[q -> rear] = data;
    // 更新队尾指针
    q -> rear = (q -> rear + 1) % MAXSIZE;
    

    删除元素:

    // 队头元素出队
    data = q -> base[q -> front];
    // 更新队头指针
    q -> front = (q -> front + 1) % MAXSIZE;
    

    循环队列判空、判满冲突

    循环队列判满、判空解决方案

    解决方案:

    1.另外设一个标致以区别队空、队满

    2.另设一个变量,记录元素个数

    3.少用一个元素空间

    本文实现的方法就是第三种。

    少用一个元素空间的循环队列判满


    循环队列常规操作

    /********************* 循环队列的常规操作 **************************/
    
    Queue    InitQueue();             	// 初始化循环队列
    int      QueueFull();               // 循环队列判满
    int      QueueEmpty();              // 循环队列判空
    int      QueueLength();             // 求循环队列长度(元素个数)
    int      EnQueue();                 // 循环队列 入队
    int      DeQueue();                 // 循环队列 出队
    
    void     QueueStatus();             // 打印队满、队空、队长状态
    /****************************************************************/
    

    定义循环队列结构体

    #include "stdio.h"
    #include "malloc.h"
    
    #define TRUE  1
    #define FALSE 0
    #define MAXSIZE 10
    
    typedef int ElemType;
    
    
    // 定义循环队列结构体
    typedef struct Queue{
    
    	int *base;	// 队列首地址
    	int front;	// 队列头下标
    	int rear;	// 队列尾下标
    
    }*Queue;
    

    初始化循环队列

    /*
     * 初始化循环队列 
    */
    Queue InitQueue(){
        Queue q;
        // 分配循环队列空间
        q -> base = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE);
        q -> front = q -> rear = 0;
        return q;
    }
    

    循环队列判满

    /*
     *  循环队列判满
     *  q 循环队列
    */
    int QueueFull(Queue q){
        if(q == NULL){
            return FALSE;
        }
        return (q -> rear + 1) % MAXSIZE == q -> front;
    }
    

    循环队列判空

    /*
     *  循环队列判空
     *  q 循环队列
    */
    int QueueEmpty(Queue q){
        if(q == NULL){
            return FALSE;
        }
        return q -> front == q -> rear;
    }
    

    计算循环队列的长度

    /*
     *  计算循环队列长度
     *  q 循环队列
    */
    int QueueLength(Queue q){
        if(q == NULL){
            return FALSE;
        }
        return (q -> rear - q -> front + MAXSIZE) % MAXSIZE;
    }
    

    循环队列 入队(EnQueue)

    /*
     *  循环队列 入队
     *  q 循环队列
     *  data 入队元素
    */
    int EnQueue(Queue q, ElemType data){
        if(QueueFull(q)){
            return FALSE;
        }
        // 队尾入队
        q -> base[q -> rear] = data;
        // 更新队尾指针
        q -> rear = (q -> rear + 1) % MAXSIZE;
        return TRUE;
    }
    

    循环队列 出队(DeQueue)

    /*
     *  循环队列 出队
     *  q 循环队列
     *  *val 用来存出队元素的数据 
    */
    int DeQueue(Queue q, ElemType *val){
        if(QueueEmpty(q)){
            return FALSE;
        }
        // 队头元素出队
        *val = q -> base[q -> front];
        // 更新队头指针
        q -> front = (q -> front + 1) % MAXSIZE;
        return TRUE;
    }
    

    循环队列各操作测试

    /*
     * 打印队满、队空、队长状态
     * q 循环队列
    */
    void QueueStatus(Queue q){
        printf("QueueFull():%d\n", QueueFull(q));
        printf("QueueEmpty():%d\n", QueueEmpty(q));
        printf("QueueLength():%d\n\n", QueueLength(q));
    }
    
    // 程序主入口
    int main(int argc, char const *argv[])
    {   
        Queue q = InitQueue();
        printf("QueueMaxSize: %d\n\n", MAXSIZE);
        QueueStatus(q); // 打印队满、队空、队长状态
    
        // 入队
        printf("EnQueue():");
        for(int i = 1; i < MAXSIZE * 2; i+=2){
            printf("%d\t", i);
            EnQueue(q, i);
        }
    
        printf("\n");
        QueueStatus(q);
    
        // 出队
        int val;
        printf("DeQueue():");
        while(!QueueEmpty(q)){
            DeQueue(q, &val);
            printf("%d\t", val);
        }
        printf("\n");
        QueueStatus(q);
    
        // 测试循环队列是否会假溢出
        int num = 20;
        printf("EnQueue(%d): %d\t(0 Failed, 1 Success)\n", num, EnQueue(q, num));
        QueueStatus(q);
        return 0;
    }
    

    结果如下:

    QueueMaxSize: 10
    
    QueueFull():0
    QueueEmpty():1
    QueueLength():0
    
    EnQueue():1     3       5       7       9       11      13      15      17      19
    QueueFull():1
    QueueEmpty():0
    QueueLength():9
    
    DeQueue():1     3       5       7       9       11      13      15      17
    QueueFull():0
    QueueEmpty():1
    QueueLength():0
    
    EnQueue(20): 1(0 Failed, 1 Success)
    QueueFull():0
    QueueEmpty():0
    QueueLength():1
    

    源代码

    源代码已上传到 GitHub Data-Structure-of-C,欢迎大家下载 C语言实现数据结构

    ✍ 码字不易,记得点赞 👍 收藏 ⭐️

    展开全文
  • 数据结构之循环队列

    2022-04-12 18:48:24
    循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。 环形队列可以使用数组实现,也可以使用循环链表实现。 重点:循环队列,无论使用数组实现还是链表实现,都要多开一个空间,也...

    目录

    一、循环队列的概念

    二、设计循环队列

    思路一:数组实现

     思路二:链表实现


    一、循环队列的概念

    为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。

    环形队列可以使用数组实现,也可以使用循环链表实现。
    重点:循环队列,无论使用数组实现还是链表实现,都要多开一个空间,也就意味着,要是一个存k个数据的循环队列,要开k+1个空间,否则无法实现判空和满

    数组实现:

     链表实现:

     

     

    二、设计循环队列

    622. 设计循环队列 - 力扣(LeetCode) (leetcode-cn.com)

    题目:设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
    循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。

    你的实现应该支持如下操作:
    MyCircularQueue(k): 构造器,设置队列长度为 k 。
    Front: 从队首获取元素。如果队列为空,返回 -1 。
    Rear: 获取队尾元素。如果队列为空,返回 -1 。
    enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
    deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
    isEmpty(): 检查循环队列是否为空。
    isFull(): 检查循环队列是否已满。

    思路一:数组实现

    代码:

    typedef struct 
    {
        int* a;//数组
        int front;
        int tail;
        int k;
    } MyCircularQueue;
    
    bool myCircularQueueIsEmpty(MyCircularQueue* obj);
    bool myCircularQueueIsFull(MyCircularQueue* obj);
    
    MyCircularQueue* myCircularQueueCreate(int k) 
    {
        //创建一个循环队列
        MyCircularQueue* cq =  (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
        //将循环多列中的成员初始化
        cq->a = (int*)malloc(sizeof(int) * (k+1));//数组创建为k+1个空间
        cq->front = cq->tail = 0;//为空
        cq->k = k;
        return cq;
    }
    
    bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
    {
        //插入,首先要判断是否满
        if(myCircularQueueIsFull(obj))
        {
            return false;
        }
        //没满就插入数值
        obj->a[obj->tail] = value;
        obj->tail++;
        //如果为尾元素,则要模除
        obj->tail %= (obj->k+1);
        return true;
    }
    
    bool myCircularQueueDeQueue(MyCircularQueue* obj) 
    {
        //删除则要判断是否为空
        if(myCircularQueueIsEmpty(obj))
        {
            return false;
        }
        //删除front++
        obj->front++;
        //如果为尾元素,则要模除
        obj->front %= (obj->k+1);
        return true;
    }
    
    int myCircularQueueFront(MyCircularQueue* obj) 
    {
        if(myCircularQueueIsEmpty(obj))
        {
            return -1;
        }
        return obj->a[obj->front];
    
    }
    
    int myCircularQueueRear(MyCircularQueue* obj) 
    {
        if(myCircularQueueIsEmpty(obj))
        {
            return -1;
        }
        //tail指向的是队尾元素的前一个节点,当tail == 0时,则队尾元素是第k个,其他的都是前一个节点
        if(obj->tail == 0)
        {
            return obj->a[obj->k];
        }
        else
        {
            return obj->a[obj->tail-1];
        }
    }
    
    bool myCircularQueueIsEmpty(MyCircularQueue* obj)
    {
        if(obj->front == obj->tail)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    bool myCircularQueueIsFull(MyCircularQueue* obj) 
    {
        if((obj->tail+1)%(obj->k+1) == obj->front)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    void myCircularQueueFree(MyCircularQueue* obj) 
    {
        free(obj->a);
        free(obj);
    }
    
    /**
     * Your MyCircularQueue struct will be instantiated and called as such:
     * MyCircularQueue* obj = myCircularQueueCreate(k);
     * bool param_1 = myCircularQueueEnQueue(obj, value);
     
     * bool param_2 = myCircularQueueDeQueue(obj);
     
     * int param_3 = myCircularQueueFront(obj);
     
     * int param_4 = myCircularQueueRear(obj);
     
     * bool param_5 = myCircularQueueIsEmpty(obj);
     
     * bool param_6 = myCircularQueueIsFull(obj);
     
     * myCircularQueueFree(obj);
    */

    运行结果:

     思路二:链表实现

    代码:

    
    typedef struct Node
    {
        int data;
        struct Node* next;
    }Node;
    
    typedef struct 
    {
      Node* head;
      Node* tail;
    } MyCircularQueue;
    
    
    bool myCircularQueueIsEmpty(MyCircularQueue* obj);
    bool myCircularQueueIsFull(MyCircularQueue* obj);
    
    MyCircularQueue* myCircularQueueCreate(int k) 
    {
         MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
         cq->head = (Node*)malloc(sizeof(Node));
         //k个元素要创建k+1个节点,所以再创建出k个节点的空间
         Node* cur = cq->head;
         while(k--)
         {
           cur->next = (Node*)malloc(sizeof(Node));
           cur = cur->next;
         }
         //将收尾连接,形成循环链表
         cur->next = cq->head;
         //初始化tail
         cq->tail= cq->head;
         return cq;
    }
    
    bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
    {
        //如果满了就返回false
        if(myCircularQueueIsFull(obj))
        {
            return false;
        }
        //如果没满就进行插入数值
        obj->tail->data = value;
        obj->tail =obj->tail->next;
        return true;
    }
    
    bool myCircularQueueDeQueue(MyCircularQueue* obj) 
    {
        //如果为空,则返回false
        if(myCircularQueueIsEmpty(obj))
        {
            return false;
        }
        obj->head = obj->head->next;
        return true;
    }
    
    int myCircularQueueFront(MyCircularQueue* obj) 
    {
        if(myCircularQueueIsEmpty(obj))
        {
            return -1;
        }
        return obj->head->data;
    }
    
    int myCircularQueueRear(MyCircularQueue* obj) 
    {
       if(myCircularQueueIsEmpty(obj))
        {
            return -1;
        }
        //队尾元素为tail的前一个节点的元素
        Node* cur = obj->tail;
        while(cur->next != obj->tail)
        {
            cur = cur->next;
        }
        return cur->data;//返回队尾元素
    }
    
    
    bool myCircularQueueIsEmpty(MyCircularQueue* obj)
    {
        if(obj->head == obj->tail)
        {
            return true;
        }
        return false;
    }
    
    bool myCircularQueueIsFull(MyCircularQueue* obj) 
    {
        if(obj->tail->next == obj->head)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    void myCircularQueueFree(MyCircularQueue* obj) 
    {
        Node* cur = obj->head;
        Node* next = obj->head;
        while(cur->next != obj->head)
        {
            next = cur->next;
            free(cur);
            cur = next;
        }
        free(cur);
        free(obj);
    }
    
    /**
     * Your MyCircularQueue struct will be instantiated and called as such:
     * MyCircularQueue* obj = myCircularQueueCreate(k);
     * bool param_1 = myCircularQueueEnQueue(obj, value);
     
     * bool param_2 = myCircularQueueDeQueue(obj);
     
     * int param_3 = myCircularQueueFront(obj);
     
     * int param_4 = myCircularQueueRear(obj);
     
     * bool param_5 = myCircularQueueIsEmpty(obj);
     
     * bool param_6 = myCircularQueueIsFull(obj);
     
     * myCircularQueueFree(obj);
    */

    运行结果:

     本文为本人对于循环链表的学习,如有问题,请评论区多多评论哈^_^

    展开全文
  • 循环队列C语言实现

    千次阅读 2019-07-30 15:07:56
    title: 循环队列 tags: 循环队列 grammar_cjkRuby: true 采用单向循环队列,实现, 使用void指针,扩展性更好,可以用于存储不同的数据结构,不单单是int,各种struct都行 可以自定义扩容算法, AddCapacity目前是...
  • import java.awt.Font; import java.util.Scanner; import javax.management.RuntimeErrorException; ... //创建队列 CircleArrayQueue circleArrayQueue = new CircleArrayQueue(4); char k
  • 里面有两个包括两个文件,.c和.h,当你使用SMT32需要用到串口中断缓存数据做判断处理的时候,希望本程序能帮助你,里面涉及到SMT32 的3个串口中断缓存程序,非常方便移植使用
  • 循环队列的基本操作,你学会了吗?

    多人点赞 热门讨论 2022-04-18 12:16:46
    编程实现循环队列的基本操作:建队列,取队头元素,入队,出队
  • 循环队列 + 用队列实现栈 ——纯C

    千次阅读 多人点赞 2022-03-31 14:46:14
    循环队列+用队列实现栈——纯C
  • 数据结构:笔记-队列-笔记

    千次阅读 2020-06-21 11:07:08
    1、对于循环队列,下列叙述正确的是( )。 正确答案: D 你的答案: D (正确) 队头指针是固定不变的 队头指针一定大于队尾指针 队头指针一定小于队尾指针 队头指针可以大于队尾指针,也可以小于队尾指针 解析:循环...
  • 数据结构之循环队列详解

    千次阅读 2021-04-11 20:02:40
    队列分为顺序队列和循环队列,顺序队列的实现有很多种方法,有数组和链表。数组实现的又分为使用队头队尾front,rear实现和利用一个变量size统计队列元素大小实现等等。并且关于size实现的顺序队列(数组和链表都实现...
  • 该代码可在VC6.0平台直接编译运行,经...用数组实现了循环队列的操作,包括入队,出队,队列是否为空,队列是否为满,以及队列的遍历输出功能,各个子函数有详细的说明……希望对正在学习数据结构的同志有所帮组……
  • 队列   队列是一种特殊的...  队列中的数据元素称为队列元素。队列中没有元素时,称为空队列。队列只允许在一端插入,另一端删除,所以队列是一种先进先出的线性表。 1. 顺序队列   顺序队列存储模式:一维数...
  • 队列只允许在表的一端进行插入(入队)、删除(出队)操作。允许插入的一端称为队尾,允许删除的一端称为队头。 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp;队列的基本操作包括: 初始化...
  • 顺序存储的队列,元素循环存储循环队列定义循环队列判空、判满循环队列长度代码实现测试结果 循环队列定义 在逻辑上把顺序存储的队列想象成一个环,就是循环队列循环队列仍是顺序存储,只是元素可以循环存储在...
  • 循环队列顺序循环队列的实现⭐1.创建初始化队列⭐2.入队⭐3.出队⭐4.队列遍历打印⭐5.清空队列⭐6.判断队列空⭐7.判断队列满⭐8.动态内存释放总结 本文涉及的完整代码及各操作测试代码均已提交至Gitee,大家可以...
  • 数据结构 顺序队列 循环队列 链对列
  • LeetCode题目链接:设计循环队列 题目描述: 思路: 1、因为队列是循环的,所以可以用循环链表实现,让链表尾指向链表头即可,但是会有一个问题就是,插入数据的时候,尾插找队列尾的时候不方便,记录队列尾...
  • 循环队列长度公式推导

    千次阅读 多人点赞 2021-07-15 16:55:50
    一、队列长度公式 队列长度=(Q.rear+MaxSize-Q.front)%MaxSize 二、队列长度公式各个变量意义 以上各个变量的意义如下: Q.rear:队尾。...2、进队操作:队列没满时,先将值送到队尾,将队尾指针加
  • 循环队列的顺序存储结构Java

    千次阅读 2019-12-19 16:33:54
    循环队列的顺序存储结构 在上次,我们讲到的是,...所以,这里就会用到循环队列,显然,这种队列也是顺序存储结构,在这个循环队列中也会去实现接口Queue。 首先,我们要想到的是如何将一般的队列改变为循环队列。 ...
  • 循环队列是对队列的一种改进,它比队列适用的范围更广,例如Linux内核当中的环形缓冲区就是基于循环队列来设计的。本文主要任务是通过C语言来实现一个循环队列的数据结构,以及对循环队列的基本操作。 1、循
  • 数据结构——图解循环队列长度计算问题

    千次阅读 多人点赞 2021-03-06 16:02:09
    队列定义是这样的 #define MAXSIZE 10 typedef struct{ ElemType data[MAXSIZE]; int front,rear;...一直rear++便到达索引最大的位置,这个时候队列就满了不能入队元素了吗? 并不,如果同时也一
  • 数据结构——循环队列PTA习题

    千次阅读 2020-12-17 23:39:58
    文章目录单选题题解函数题6-1 另类循环队列 (20分)输入样例:输出样例:代码6...在用数组表示的循环队列中,front值一定小于等于rear值。 错 3 为解决计算机主机与打印机之间速度不匹配问题,通常设置一个打印数据缓
  • 数据结构(C语言)循环队列

    千次阅读 2022-04-27 15:52:36
    循环队列 1.静态队列为什么必须是循环队列 因为不是循环队列,f只能增,会浪费存储空间 2.循环队列需要几个参数来确定 两个参数 font rear 3.循环队列各个参数的含义 两个参数在不同场合意义不一样 1.对列初始化 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 297,948
精华内容 119,179
关键字:

在循环队列中