数据结构学习之循环队列（顺序存储）

最新推荐文章于 2023-04-15 23:09:35 发布
最新推荐文章于 2023-04-15 23:09:35 发布
阅读量1.3k 收藏 1
点赞数 2
分类专栏： 数据结构和算法 Leetcode 文章标签： 队列 循环队列 顺序存储 OJ系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy010902100449/article/details/46559567
版权

【摘要】队列特性：先进先出（FIFO)——先进队列的元素先出队列。来源于我们生活中的队列（先排队的先办完事）。
这里写图片描述
这样有个缺陷，空间利用率不高，所以我们直接学习循环队列（基于连续内存的）。

这里写图片描述
（1）设计队列数据结构

typedef struct _QUEUE_NODE
{
    int* pData;
    int length;//队列长度
    int head ;//队头指针
    int tail;//队尾指针
    int count;//队列元素当前个数
}QUEUE_NODE;

（2）申请队列内存

QUEUE_NODE* alloca_queue(int number)
{
    QUEUE_NODE* pQueueNode;
    if( 0 == number)
        return NULL;

    pQueueNode = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE));
    assert(NULL != pQueueNode);
    memset(pQueueNode, 0, sizeof(QUEUE_NODE));

    pQueueNode->pData = (int*)malloc(sizeof(int) * number);
    if(NULL == pQueueNode->pData){
        free(pQueueNode);
        pQueueNode = NULL;
        return NULL;
    }

    pQueueNode->length = number;//队列长度
    return pQueueNode;
}

(3）释放队列内存

STATUS delete_queue(const QUEUE_NODE* pQueueNode)
{
    if(NULL == pQueueNode) 
        return FALSE;

    assert(NULL != pQueueNode->pData);

    free(pQueueNode->pData);
    free((void*)pQueueNode);
    return TRUE;
}

(4) 把数据压入队列

STATUS insert_queue(QUEUE_NODE* pQueueNode, int value)
{
    if(NULL == pQueueNode)
        return FALSE;

    if(pQueueNode->length == pQueueNode->count)//判断是不是溢出
        return FALSE;

    pQueueNode->pData[pQueueNode->tail] = value;
    pQueueNode->tail = (pQueueNode->tail + 1) % pQueueNode->length;  //队尾指针位置
    pQueueNode->count ++;
    return TRUE;
}

(5)把数据弹出队列

STATUS get_queue_data(QUEUE_NODE* pQueueNode, int* value)
{
    if(NULL == pQueueNode || NULL == value)
        return FALSE;

    if(0 == pQueueNode->count)
        return FALSE;

    *value = pQueueNode->pData[pQueueNode->head];
    pQueueNode-> pData[pQueueNode->head] = 0; //被弹出的位置赋值为0
    pQueueNode-> count --;
    pQueueNode->head = (pQueueNode->head + 1) % pQueueNode->length;//重新定位队头指针的位置
    return TRUE;
}

(6)统计当前队列中有多少数据

int  get_total_number(const QUEUE_NODE* pQueueNode)
{
    if(NULL == pQueueNode)
        return 0;

    return pQueueNode->count;
}

(7)查看队列中初始化的时候总长度是多少

int  get_total_number(const QUEUE_NODE* pQueueNode)
{
    if(NULL == pQueueNode)
        return 0;

    return pQueueNode->length;
}
// 循环队列.cpp : 定义控制台应用程序的入口点。
//
//循环队列
//Written by ZP1015
//2015.10.21

#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct QUEUE_NODE
{
    int* pData;
    int QueueLenMax;//队列最大长度
    int head ;//队头指针
    int tail;//队尾指针
    int QueueCurLen;//队列元素当前个数
};

struct QUEUE_NODE* alloc_queue(int Queue_Max_Size)
{

    if(Queue_Max_Size <= 0)
        return NULL;

    struct QUEUE_NODE* pQueueNode  = NULL;

    pQueueNode = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE));
    if(NULL == pQueueNode) {
        return NULL;
    }
    memset(pQueueNode, 0, sizeof(struct QUEUE_NODE));

    pQueueNode->pData = (int*)malloc(sizeof(int) * Queue_Max_Size);
    if(NULL == pQueueNode->pData) {
       goto malloc_failed;
    }

    pQueueNode->QueueLenMax = Queue_Max_Size;//队列长度
    pQueueNode->head = 0;
    pQueueNode->tail = 0;
    pQueueNode->QueueCurLen = 0;

    return pQueueNode;

malloc_failed:
    free(pQueueNode);
    return NULL;
}

int free_queue(struct QUEUE_NODE* pQueueNode)
{
    if(NULL == pQueueNode) 
        return -1;

    if(NULL == pQueueNode->pData) {
        free(pQueueNode);
        return -1; 
    }

    free(pQueueNode->pData);
    free(pQueueNode);

    return 0;
}

int queue_push(struct QUEUE_NODE* pQueueNode, int value)
{
    if(NULL == pQueueNode)
        return -1;

    if(pQueueNode->QueueLenMax == pQueueNode->QueueCurLen)//判断是不是溢出
        return -1;

    pQueueNode->pData[pQueueNode->tail] = value;
    pQueueNode->tail = (pQueueNode->tail + 1) % pQueueNode->QueueLenMax;  //队尾指针位置
    pQueueNode->QueueCurLen ++;

    return 0;
}

int queue_pop(struct QUEUE_NODE* pQueueNode, int* value)
{
    if(NULL == pQueueNode || NULL == value)
        return -1;

    if(0 == pQueueNode->QueueCurLen)
        return -1;

    *value = pQueueNode->pData[pQueueNode->head];
    pQueueNode->pData[pQueueNode->head] = 0; //被弹出的位置赋值为0

    pQueueNode->QueueCurLen --;
    pQueueNode->head = (pQueueNode->head + 1) % pQueueNode->QueueLenMax;//重新定位队头指针的位置

    return 0;
}

int get_queue_curlen(struct QUEUE_NODE* pQueueNode)
{
    if(NULL == pQueueNode)
        return -1;

    return pQueueNode->QueueCurLen;
}

int get_queue_maxlen(struct QUEUE_NODE* pQueueNode)
{
    if(NULL == pQueueNode)
        return 0;

    return pQueueNode->QueueLenMax;
}

void print_queue_node(struct QUEUE_NODE *pQueueNode) 
{
    /*1.输入的参数有误*/
    if(NULL == pQueueNode) {
        printf("[%d] pQueueNode is illegal! \n",__LINE__);
        return;
    }
    /*2.输入的链式堆栈为空*/
    if(0 == pQueueNode->QueueCurLen) {
        printf("[%d] pQueueNode is empty!\n",__LINE__);
        return ;
    }

    struct QUEUE_NODE *pQueueNodeTemp = pQueueNode;
    int count = 0;

    while(count < pQueueNode->QueueCurLen) {
        printf("%d ",pQueueNode->pData[pQueueNode->head+count]);
        count++;;
    }
    printf("\n");
}


int main()
{
    struct QUEUE_NODE *pQueueNode;
    pQueueNode = alloc_queue(20);
    int i = 0;
    for (i = 0;i<10;i++) {
        queue_push(pQueueNode,i);
    }
    print_queue_node(pQueueNode);
    int a = 0;
    queue_pop(pQueueNode,&a);
    print_queue_node(pQueueNode);

    free_queue(pQueueNode);

    getchar();
    getchar();

    return 0;
}

OJ 系列循环队列的基本操作

/******************************************************************************

  Copyright (C), 2001-2011, SCUT.

 ******************************************************************************
  File Name     : 
  Version       : 
  Author        : 
  Created       : 2016/01/21
  Last Modified :
  Description   : 
  Function List :

  History       :
  1.Date        : 2016/01/21
    Author      : 
    Modification: Created file

******************************************************************************/
#include <stdlib.h>

#define MAXSIZE 50

struct strqueue {
    int queue[MAXSIZE];
    int head; /* 队头 */
    int tail; /* 队尾 */
    int num;  /* 队元素个数 */
};

/* 初始化队列，返回0表示失败，返回1表示成功 */
bool initqueue(struct strqueue *s) 
{
    if(!s)
        return 0;
    for(int i = 0;i<MAXSIZE;i++) {
        s->queue[i] = 0;
    }
    s->head = -1;
    s->tail = -1;
    s->num = 0;

    return 1;
}

bool enqueue(struct strqueue *s, int x) /* 进队列，返回0表示失败，返回1表示成功 */
{
    if(!s)
        return 0;
    if(s->num == MAXSIZE )
        return 0;

    if(s->head==-1||s->tail==-1) {
        s->head = 0;
        s->tail = 0;
        s->queue[s->tail] = x; /*赋值*/
        s->num  = 1;
        return 1;
    } 

    s->tail  =  (s->tail + 1) % MAXSIZE;/*从队尾入队列*/
    s->queue[s->tail] = x; /*赋值*/

    s->num ++;

    return 1;
}

bool dequeue(struct strqueue *s, int *x) /* 出队列，返回0表示失败，返回1表示成功 */
{
    if(!s||!x)
        return 0;
    if(s->num == 0)
        return 0;

    *x = s->queue[s->head]; /*赋值*/
    s->queue[s->head] = 0;

    s->head  =  (s->head + 1) % MAXSIZE;/*从对头出队列*/
    s->num --;

    if(s->num==0) {
        s->head = -1;
        s->tail = -1;
    }

    return 1;

}

int gethead(struct strqueue *s)  /* 获得队列头数值 */
{   
    if(!s)
        return -1;

    if(s->num==0)
        return -1;

    int head = 0;
    head = s->queue[s->head];

    return head;
}


int gettail(struct strqueue *s)  /* 获得队列尾数值 */
{
    if(!s)
        return 0;

    int tail = 0;

    if(s->num==0)
        return -1;

    tail=s->queue[s->tail];

    return tail;
}

int getqueuelenth(struct strqueue *s)  /* 获得队列长度 */
{
    if(!s)
        return 0;

    int lenth = 0;
    lenth = s->num;

    return lenth;
}

bool search(struct strqueue *s, int x)  /* 在队列中查找x是否存在，如果存在返回1，否则返回0 */
{
    if(!s)
        return 0;

    int headTemp = s->head;
    int tailTemp = s->tail;
    /*1.队列为满的情况*/
    if(s->num == MAXSIZE) {
        for(int i=0;i<MAXSIZE;i++) {
            if(x==s->queue[i])
                return 1;
        }
    } else {
    /*2.队列不满,从head到tail处是存在元素的*/
        while(headTemp!=tailTemp) {
            if(x==s->queue[headTemp])
                return 1;
            headTemp=(headTemp + 1) % MAXSIZE;
        }
    }


    return 0;
}
狂奔的乌龟
关注
专栏目录
数据结构：队列的顺序存储结构（循环队列）
Meditation
04-23 5074
队列（Queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。是一种先进先出的线性表（FIFO）。允许插入的一端称为队尾，允许删除的一端称为队头。我们在《栈的顺序存储结构》中发现，栈操作的top指针在Push时增大而在Pop时减小，栈空间是可以重复利用的，而队列的front、rear指针都在一直增大，虽然前面的元素已经出队了，但它所占的存储空间却不能重复利用。但大多数程序并不是这样
C语言数据结构——循环队列
sunshine_rebrith的博客
05-08 819
1、若队列的最大尺寸为QueueSize,则队列满的条件是(rear+1)%Queue == Q.front;计算队列长度的公式是：（rear - front + QueueSize）%QueueSize 2、循环队列的顺序存储结构#include<stdio.h> #include<stdlib.h> #include<math.h> #define OVERLOW -1 #define FAL
5、队列的顺序存储结构：循环队列、两种方法
ajiaoci0000的博客
04-07 280
队列的ADT： 1 package ren.laughing.datastructure.base; 2 3 import ren.laughing.datastructure.exception.QueueEmptyException; 4 5 /** 6 * 队列Queue的ADT:先进先出 7 * 在队列中把插入数据元素的一端称为 队尾(re...
循环队列的顺序存储实现
寒梅煮雪
11-20 310
/*用数组实现队列的顺序存储*/ #include <stdio.h> #define MaxSize 20 #define ElementType int #define ERROR -1 struct QNode{ ElementType Data[MaxSize]; int front; int rear; }; typedef struct QNode *Queu
c语言循环队列是什么存储结构,C语言队列的顺序存储结构实现（循环队列）
weixin_39625258的博客
05-17 208
#include"bits/stdc++.h";#define max 100/**循环队列关键 rear在front的后一位来分辨满与空 巧妙取模实现循环*/typedef struct queue{int *base;int front;int rear;}Queue;void initiaStack(Queue &stack){stack.base=(int *)malloc(siz...
循环队列的顺序存储
kelvinmao的博客
03-20 1123
在学习队列的过程中，我积累了一些更好的分析问题的方法，现加以总结，如下:1.对于队列的顺序存储结构，如果要将第一个元素存在数组的第一个位置，则之后在插入和删除时平均要移动n个元素，时间复杂度为O(n); 细细想来，其实不把第一个元素放在第一个位置上也可以，这种方案不仅仅是增强了灵活性，更重要的是它解决了插入删除过程中移动n个元素的问题； 由于第一个元素不需要在第一个位置上，队
C++数据结构之实现循环顺序队列
08-31
循环顺序队列是一种在计算机科学中常见的数据结构，它继承了普通顺序队列的特性，同时解决了顺序队列在处理满状态时可能出现的问题。...理解并正确实现循环顺序队列对于学习和掌握数据结构与算法至关重要。
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
数据结构之循环顺序队列
05-30
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和操作数据。循环顺序队列是数据结构中的一种，尤其在处理大量数据的输入输出时，它的效率和灵活性显得尤为重要。循环顺序队列是对普通顺序队列的改进，...
Python 实现数据结构-循环队列的操作方法
09-19
### Python 实现数据结构——循环队列的操作方法 #### 一、引言 在计算机科学领域，数据结构是算法设计的基础。不同的数据结构能够解决不同的问题，并且在效率上也存在差异。队列作为一种基本的数据结构，其先进先...
循环队列
爱笑的余尔
05-08 513
typedef int * Pint; typedef struct{ Pint *base; int front; int rear; int queuesize; }SqQueue; 1.初始化 void initqueue(SqQueue &Q,int max){ Q.base=new Pint[max]; Q.front=Q.rear=0; Q.qu
数据结构：链式栈 不定长顺序栈
Kobe51920的博客
01-08 314
栈的概念： 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 链式栈：利用带头结点的单链表实现 栈只能在栈顶进行操作 ...
数据结构-队列的顺序存储（循环队列）
weixin_33711647的博客
05-07 76
1 #include "stdio.h" 2 #include "stdlib.h" 3 4 #define OK 1 5 #define ERROR 0 6 #define OVERFLOW -1 7 #define MAXQSIZE 100 8 typedef int QElemType; 9 typedef int Status; 10 11 t...
笔记七：基于数组的循环队列的实现
慢慢的专栏
05-07 1996
定义：队列也是一种线性表。其特点是队列的插入与删除在两端进行，是一个先进先出（FIFO）的线性表。插入元素的一端叫队尾，删除元素的一端叫队首。三种表现形式：1、 公式1： location（i）=i ——队列第i个元素映射到数组中，即为下标为i的元素，i>=0。 2、 公式2：location（i）=location（队首元素）+i ——队列第i个元素在数组中的位置只与队首元素有关，则删除
数组实现顺序队列、顺序循环队列
dch9210的博客
03-20 687
一、数组实现顺序队列 /** * 顺序队列 此实现会出现假溢出现象 * * @author Administrator * */ public class MyArrayQueue implements Serializable {/** * */ private static final long serialVersionUID = 74811495914348
【数据结构】队列（循环队列和链队列）详细讲解各种操作
最新发布
小吉妙妙屋
04-15 5395
详细讲解循环队列和链队列的定义，初始化，入队，出队，遍历等操作
数据结构——循环队列存储结构以及实现
Cary程祺
10-30 5990
队列的顺序存储结构，是将元素存在一个一维数组中，队头所在的位置下标是0，当要入队操作时，直接在队尾后一个位置插入一个结点即可，时间复杂度为O(1)。而出队列，出队的元素下标为0，所以队列中所有的元素都要向前移动，时间复杂度为O(n)。如果不去限制队头的元素必须存在下标为0的位置，那么也可以做到时间复杂度为O(1)。为了避免只有一个元素时，队头队尾重合使得处理变得麻烦，于是设置两个指针，front指向
队列的顺序存储——循环队列
知足~的博客
05-16 1294
队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表。 1.允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。 队列的这种首尾相接的顺序存储称为循环队列。 1.为了实现元素出队之后，不移动其他的数据元素，并且可以循环利用空闲下来的数组空间。 2.队空的条件：start==rear。 3.队满的条件：(rear+1)%QueueSize==start。
顺序循环队列的表示和实现(少用一个存储空间)
罗小黑の窝
02-10 4365
头文件：函数的声明 #include #include #define QUEUESIZE 100 typedef char ElemType; typedef struct { ElemType queue[QUEUESIZE]; int front; int rear; }SeqQueue; void InitQueue(SeqQueue *SCQ); int QueueEmp
初始化循环队列顺序存储实现与数据结构基础
本资源主要介绍了在软件开发中关于循环队列的顺序存储空间管理和初始化的相关知识。循环队列是一种特殊的线性表，它通过在数组的两端进行操作来实现“队尾”和“队头”的概念，这样可以避免普通队列在尾部扩展时可能...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

狂奔的乌龟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值