数据结构(六)循环队列的基本操作 入队 退队

  
队列特性:先进先出(FIFO)——先进队列的元素先出队列。来源于我们生活中的队列(先排队的先办完事)。
采用空闲一个位置的方式,即N个元素空间的循环队列最多只能存放N-1个有效元素。这也是大多数教材的做法。

  1. 队列有下面几个操作:
void init(PQUEUE);//初始化 
void in(PQUEUE);//入队 
void out(PQUEUE,int *);//出队 
void printQueue(PQUEUE);//打印队列 
bool is_empty(PQUEUE);//队列是否为空 
bool is_full(PQUEUE);//队列是否满 

1) 循环队列初始化:front=rear=0;
2)入队操作:rear=(rear+1)%size;
3)出队操作:front=(front+1)%size;
4)判断是否为空队列:front==rear;
5)判断队列是否已满:front=(rear+1)%size;
6)遍历队列各元素。

#include <stdio.h>
#include <malloc.h>
//静态队列,循环队列 
typedef struct Queue{
    int * base; 
    int front;//队首
    int rear;//队尾 
    int len;//队列长度 
}QUEUE,*PQUEUE;
void init(PQUEUE);//初始化 
void in(PQUEUE);//入队 
void out(PQUEUE,int *);//出队 
void printQueue(PQUEUE);//打印队列 
bool is_empty(PQUEUE);//队列是否为空 
bool is_full(PQUEUE);//队列是否满 
int main(void){
    QUEUE q;
    int val; 
    init(&q);
    in(&q); 
    in(&q); 
    in(&q); 
    printQueue(&q); 
    out(&q,&val); 
    printf("出队的元素是:%d\n",val); 
    printQueue(&q);
    return 0; 
} 
//队列初始化 
void init(PQUEUE pQ){
    int len;
    printf("请输入需要存储几个元素:");
    scanf("%d",&len); 
    pQ->base =(int*)malloc( sizeof(int)*(len+1) );//因为队尾是最后一个元素的下一个元素,所以要加一 
    if(pQ->base == NULL){
        printf("初始化,分配内存失败."); 
        exit(-1); 
    } 
    pQ->front = pQ->rear = 0; 
    pQ->len = len; 
}
//入队,队首总是指向第一个元素,队尾总是指针最后一个有效元素的下一个元素(一般为NULL) 
void in(PQUEUE pQ){
    if(is_full(pQ)){
        printf("该队列已满,不能入队\n");
        return; 
    } 
    int val;
    printf("请输入值:");
    scanf("%d",&val);
    pQ->base[pQ->rear] = val;
    pQ->rear = (pQ->rear+1)%pQ->len; 
}
//出队 
void out(PQUEUE pQ,int * pVal){
    if( is_empty(pQ) ){
        printf("该队列为空,不能出错\n");
        return; 
    } 
    *pVal = pQ->base[pQ->front];
    pQ->front = (pQ->front+1)%pQ->len; 
}
//打印队列 
void printQueue(PQUEUE pQ){
    if( is_empty(pQ) ){
        printf("该队列为空\n");
        return; 
    } 
    printf("队列的元素为:"); 
    int t = pQ->front; 
    while(t != pQ->rear){
        printf("%d ",pQ->base[t]);
        t = (t+1)%pQ->len; 
    } 
    printf("\n"); 
} 
//判断队列是否为空 
bool is_empty(PQUEUE pQ){
    return pQ->front == pQ->rear; 
} 
//判断队列是否已满 
bool is_full(PQUEUE pQ){
    return (pQ->rear+1)%pQ->len == pQ->front; 
} 
  • 4
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 数据结构二级指针循环队列基本操作包括: 1. 初始化队列:创建一个二级指针循环队列,设置队头和队尾指针为0。 2. 判断队列是否为空:判断队头和队尾指针是否相等,如果相等则队列为空。 3. 判断队列是否已满:判断队尾指针加1后是否等于队头指针,如果相等则队列已满。 4. 入队操作:将元素插入队尾指针所指向的位置,队尾指针加1。 5. 出队操作:将队头指针所指向的元素删除,队头指针加1。 6. 获取队头元素:返回队头指针所指向的元素。 7. 获取队列长度:返回队尾指针减去队头指针的值。 8. 清空队列:将队头和队尾指针都设置为0,清空队列中的元素。 以上就是数据结构二级指针循环队列基本操作。 ### 回答2: 数据结构是计算机科学的基础课程,其中二级指针循环队列是一种比较常见的数据结构。下面将详细介绍二级指针循环队列基本操作c。 1.初始化队列 二级指针循环队列的初始化操作需要分配内存空间,并初始化队列基本信息,如队头、队尾等。具体操作如下: ``` int **initQueue(int maxSize) { int **queue = (int **) malloc(sizeof(int *) * (maxSize + 1)); for (int i = 0; i <= maxSize; i++) { queue[i] = (int *) malloc(sizeof(int) * 2); queue[i][0] = 0; queue[i][1] = 0; } return queue; } ``` 2.判断队列是否为空 判断队列是否为空需要检查队列基本信息,如队头、队尾等。具体操作如下: ``` bool isQueueEmpty(int **queue) { return queue[tail][0] == queue[head][0] && queue[tail][1] == queue[head][1]; } ``` 3.判断队列是否已满 判断队列是否已满同样需要检查队列基本信息,并比较队头和队尾之间的距离是否为最大容量减一。具体操作如下: ``` bool isQueueFull(int **queue, int maxSize) { return getQueueLength(queue, maxSize) == maxSize; } ``` 4.入队操作 入队操作需要检查队列是否已满,如果未满,则在队尾插入元素。具体操作如下: ``` bool enqueue(int **queue, int maxSize, int value) { if (isQueueFull(queue, maxSize)) { return false; } queue[tail][1] = value; tail = (tail + 1) % (maxSize + 1); return true; } ``` 5.出队操作 出队操作需要检查队列是否为空,如果不为空,则从队头弹出元素。具体操作如下: ``` bool dequeue(int **queue, int maxSize) { if (isQueueEmpty(queue)) { return false; } head = (head + 1) % (maxSize + 1); return true; } ``` 6.获取队列长度 获取队列长度需要计算队列中元素的个数。具体操作如下: ``` int getQueueLength(int **queue, int maxSize) { int length; if (tail > head) { length = tail - head; } else { length = maxSize + 1 - head + tail; } return length; } ``` 以上即为二级指针循环队列基本操作c,通过以上操作可以实现队列的基本功能,如入队出队、判断队列是否为空或已满、获取队列长度等。它在实际编程中被经常用到,是数据结构学习的重点之一。 ### 回答3: 二级指针循环队列,也被称为双端队列,是一种常用的数据结构,它支持在队列的两端插入和删除元素。在C语言中实现双端队列需要使用二级指针来操作队列中的元素,主要有以下几个操作: 1. 初始化队列 初始化队列时,需要动态分配一段空间存储队列元素,同时创建两个指针,一个指向队头,另一个指向队尾。初始化操作的实现如下: ``` void initQueue(Queue **queue) { *queue = (Queue *)malloc(sizeof(Queue)); (*queue)->front = (*queue)->rear = (QNode *)malloc(sizeof(QNode)); (*queue)->front->next = NULL; } ``` 2. 判断队列是否为空 判断队列是否为空时只需要判断队头和队尾是否指向同一个节点。如果是,则队列为空;反之,队列不为空。操作代码如下: ``` bool isEmpty(Queue *queue) { return queue->front == queue->rear; } ``` 3. 入队 元素入队时需要在队尾插入元素,并更新队列的rear指针。操作代码如下: ``` void enQueueRear(Queue *queue, int value) { QNode *node = (QNode *)malloc(sizeof(QNode)); node->data = value; node->next = NULL; queue->rear->next = node; queue->rear = node; } ``` 4. 出队 元素出队时需要在队头删除元素,并更新队列的front指针。操作代码如下: ``` int deQueueFront(Queue *queue) { if (isEmpty(queue)) { printf("Queue is empty!\n"); return -1; } else { QNode *node = queue->front->next; int value = node->data; queue->front->next = node->next; if (node == queue->rear) { queue->rear = queue->front; } free(node); return value; } } ``` 5. 队列长度 队列长度即队列中元素的个数,可以通过遍历队列节点计算得出。操作代码如下: ``` int length(Queue *queue) { int len = 0; QNode *node = queue->front->next; while (node) { len++; node = node->next; } return len; } ``` 6. 清空队列 清空队列即删除队列中所有元素,需要遍历队列节点,并依次删除每个节点。操作代码如下: ``` void clearQueue(Queue *queue) { QNode *node = queue->front->next; while (node) { QNode *temp = node; node = node->next; free(temp); } queue->front->next = NULL; queue->rear = queue->front; } ``` 以上就是数据结构二级指针循环队列基本操作C语言代码。在实现双端队列时需要注意指针的操作,以及动态分配和释放内存的方法。双端队列的使用场景很多,如操作系统任务调度、生产者消费者模型等等。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值