精华内容
下载资源
问答
  • 循环队列中,我用的是少用一个元素空间的方法来区别空和满。 空:q->front = q ->rear;满:(q->rear+1)%MAXSIZE = q->front,具体代码如下: #include <stdio.h&...

    为了解决一般队列“假溢出”的问题,出现了循环队列,即最后一个元素的后继是第一个元素。

    在循环队列中,我用的是少用一个元素空间的方法来区别队空和队满。

    队空:q->front = q ->rear;队满:(q->rear+1)%MAXSIZE = q->front,具体代码如下:

    #include <stdio.h>
    #include <malloc.h>
    #define MAXSIZE 10
    typedef struct{
    	int data[MAXSIZE];
    	int front,rear; 
    }CSeQueue;
    //队列的初始化 
    CSeQueue *Init_Queue(){
    	CSeQueue *q;
    	q = (CSeQueue *)malloc(sizeof(CSeQueue));
    	q->front = q->rear = 0;
    	return q;
    }
    //判队满 
    int Full_Queue(CSeQueue *q){
    if((q ->rear + 1) % MAXSIZE == q ->front){
    	return 1;
    }else
    return 0;
    }
    //入队
    int In_Queue(CSeQueue *q,int x){
    if(Full_Queue(q)){	
    printf("队满");
    return 0;
    }
    else{
    	q ->rear = (q ->rear + 1) % MAXSIZE;
    	q ->data[q ->rear] = x;
    	return 1;
    }
    }
    // 判队空
     int Empty_Queue(CSeQueue *q){
     	if(q ->front == q ->rear)
     	return 1;
     	else 
     	return 0;
     }
     
    //出队
    int Out_Queue(CSeQueue *q,int *x){
    	if(Empty_Queue(q)){
    		printf("队空");
    		return 0;
    	}else {
    		q ->front = (q ->front + 1) % MAXSIZE;
    		*x = q ->data[q ->front];
    		return 1;
    	}
    	
    } 
    
    //打印输出队列中的元素 
    void printf_Queue(CSeQueue *q){
     	int i = q ->front;
     	printf("队列中的元素是:");
     	while(i != q ->rear){
     		printf("%d ",q ->data[i+1]);
     		i ++;
     		i = i % MAXSIZE;
    	 }
     }
     //求队列的长度 
     int Queue_Length(CSeQueue *q){
    	return(q->rear - q->front + MAXSIZE) % MAXSIZE;
    }
    
     int main(){
     	//队列初始化 
     	CSeQueue *q;
     	q = Init_Queue();
     	//插入第一个元素 
        printf("将元素1插入到队尾后的结果:\n");
    	In_Queue(q,1);    
        printf_Queue(q);  
        printf("循环队列长度=%d\n",Queue_Length(q));
    //	插入第二个元素 
    	printf("将元素2插入到队尾后的结果:\n");
    	In_Queue(q,2);
        printf_Queue(q);  
    	printf("循环队列长度=%d\n",Queue_Length(q));
    //	插入第三个元素 
    	printf("将元素3插入到队尾后的结果:\n");
    	In_Queue(q,3);
        printf_Queue(q);  
    	printf("循环队列长度=%d\n",Queue_Length(q));
    //	删除第一个元素 
    	int a;
    	Out_Queue(q,&a);
    	printf("出队的元素是:%d\n",a);
    	printf_Queue(q);  
    	printf("循环队列长度=%d\n",Queue_Length(q));
    	
     } 

    运行结果:

    展开全文
  • 计算循环队列元素个数

    千次阅读 2017-07-03 19:27:27
    队列头指针为front,队列尾指针为rear,队列容量为maxsize 队空:front==rear ...队中元素个数n=(rear-front+maxsize )mod maxsize 入队:rear=(rear+1) % maxsize ; 出队:front=(front+1) % maxsize ;
    队列头指针为front,队列尾指针为rear,队列容量为maxsize 
    队空:front==rear
    队满: (rear+1) mod maxsize ==front
    队中元素个数n=(rear-front+maxsize )mod maxsize 
    入队:rear=(rear+1) % maxsize ;
    出队:front=(front+1) % maxsize ;
    展开全文
  • 设一循环队列Queue,只有头指针front,不设尾指针,另设一个内含元素个数的计数器,试写出相应的进队、出队算法。
  • 假设以一维数组elem[0…m-1]存储循环队列的元素,同时设变量rear和quelen分别指示循环队列中队尾元素的位置和队列中所含元素个数。 (1)说明该队列特点 (2)给循环队列空、满条件 (3)编程实现入队列算法 (4)...

    问题引入:

    假设以一维数组elem[0…m-1]存储循环队列的元素,同时设变量rear和quelen分别指示循环队列中队尾元素的位置和队列中所含元素个数。
    (1)说明该队列特点
    (2)给出该循环队列的队空、队满条件
    (3)编程实现入队列算法
    (4)编程实现出队列算法

    分析:

    结构体:

    typedef struct node {
    	DataType elem[M];
    	int rear;//队尾指针
    	int quelen;//元素个数
    }SeQueue;
    

    SeQueue Q;

    队空条件:Q.quelen == 0
    
    队满条件:Q.quelen == M
    

    代码实现:

    LQueue.h:

    #pragma once
    typedef struct node {
    	DataType elem[M];
    	int rear;//队尾指针
    	int quelen;//元素个数
    }SeQueue;
    //初始化
    void Initiate(SeQueue *Q) {
    	Q->quelen = 0;
    	Q->rear = -1;
    }
    //入队列
    int Insert(SeQueue &Q, DataType x)
    {
    	if (Q.quelen == M)//队列已满
    	{
    		printf("队列已满!");
    		return 0;
    	}
    	Q.rear = (Q.rear + 1) % M;
    	Q.elem[Q.rear] = x;
    	Q.quelen++;
    	return 1;
    }
    //出队列
    int Delete(SeQueue &Q, DataType *x)
    {
    	if (Q.quelen == 0)//队列已空
    	{
    		printf("队列已空!");
    		return 0;
    	}
    	*x = Q.elem[(Q.rear - Q.quelen + 1 + M)%M];
    	Q.quelen--;
    	return 1;
    }
    
    
    

    test.cpp

    #include<stdio.h>
    #include<stdlib.h>
    typedef int DataType;
    constexpr auto M = 100;
    #include"LQueue.h"
    int main() {
    	int x;
    	SeQueue Queue;
    	Initiate(&Queue);
    	for (int i = 0; i < 10; i++)
    	{
    		Insert(Queue, i + 1);
    	}
    	int length = Queue.quelen;
    	printf("出队列的顺序如下:\n");
    	for (int i = 0; i < length; i++) {
    		Delete(Queue, &x);
    		printf("%d ", x);
    	}
    
    	return 0;
    }
    

    运行结果

    先插入10个元素,再依次出队列
    在这里插入图片描述

    展开全文
  • 描述 根据给定的空间构造顺序循环队列,规定队满处理方法为少用一个元素空间。例如,给定5个元素空间构造...输入的第一行为一自然数n,表示要求构造的顺序循环队列空间。第二行为操作次k,接下来k行为出队入队...

    描述

    根据给定的空间构造顺序循环队列,规定队满处理方法为少用一个元素空间。例如,给定5个元素空间构造循环队列,则只能存放4个元素。试根据入队及出队操作判断队列最后的元素存放情况,并输出最后队列中的元素值,即完成给定入队及出列操作后一次性全部出队的元素值。要求采用顺序队列完成。

    输入

    输入的第一行为一个自然数n,表示要求构造的顺序循环队列空间数。第二行为操作次k,接下来k行为出队入队操作,每行各代表一次操作。入队用in表示,出队用out表示,如果是入队,则in隔一空格后为一整数,表示入队元素值。

    输出

    输出完成所有入队出队操作后,一次性出队元素。用一个空格隔开。可以假定队在完成所有操作后不为空。

    样例输入

    4

    7

    in 1

    in 2

    in 5

    in 6

    out

    out

    in 8

    样例输出

    5 8

    #include"iostream"
    #include"string"
    using namespace std;
    typedef int element;
    class Queue{
    private:
        element *arr;
        int front;
        int maxsize;
        int tail;
    public:
        Queue(int size){
            maxsize = size;
            arr = new  element[size];
            front = 0;
            tail = 0;
        }
        bool empty(){
            return tail == front;
        }
        bool full(){
            return (tail + 1) % maxsize == front;
        }
        bool push(element data){
            if(full()){
                cout<<"out"<<endl;
                return false;
            }
            arr[tail] = data;
            tail = (tail + 1) % maxsize;
            return true;
        }
        int length(){
            return (tail - front + maxsize) % maxsize;
        }
        element pop(){
            if(empty()){
                return false;
            }
            int temp = front;
            front = (front + 1) % maxsize;
            return arr[temp];
            
        }
        element getFront(){
            if(empty()){
                return arr[-1];
            }
            return arr[front];
        }
    };
    int main(){
        element data;
        int n;
        string s;
        cin>>n;
        Queue myq(n);
        cin>>n;
        while(n--){
            cin>>s;
            if(s=="in"){
                cin>>data;
                myq.push(data);
            }
            else{
                myq.pop();
            }
        }
        while(!myq.empty()){
            cout<<myq.pop()<<ends;
        }
        cout<<endl;
        return 0;
    }
    /*
    4
    7
    in 1
    in 2
    in 5
    in 6
    out
    out
    in 8
    
    */

     

    展开全文
  • bool AddQ(Queue Q, ElementType X) { if (Q->Count == Q->MaxSize) { printf("Queue Full"); return false; } Q->Count++; Q->Data[(Q->Count +...}
  • 简介 队列就是一种先进先的数据结构 循环队列就是队列首尾相连,容量固定的环 对于循环队列 需要判断当前是否队列可以插入 也就是是否满了...最多容纳元素个数: (rear-front+maxsize)%maxsize 代码实现 #include
  • 和求元素的总数思路一样,你可以认为求当前元素的前方元素(不包含当前元素)的个数, 即为求尾指针rear = index时的元素个数,而这就是求元素总数. 换句话说, 我就是想知道插入index元素的时候的总数(就算有出队操作). ...
  • 循环队列

    2018-04-13 11:57:40
    试根据入队及出队操作判断队列最后的元素存放情况,并输出最后队列中的元素值,即完成给定入队及出列操作后一次性全部出队元素值。要求采用顺序队列完成,少用一存储空间的方法区分队列的空和满。输入输入的第一...
  • 带有元素个数size的编写方式2.1条件假设2.2编写逻辑2.3实现代码3.不带元素个数的编写方式3.1条件假设3.2编写逻辑3.3实现代码 1.前言 环形队列有两种编写方式,一种是队列中包含元素的个数,另外一种是不包含元素的...
  • 循环队列和队列

    2013-08-09 08:51:36
    试根据入队及出队操作判断队列最后的元素存放情况,并输出最后队列中的元素值,即完成给定入队及出列操作后一次性全部出队元素值。要求采用顺序队列完成。 输入 输入的第一行为一自然数n,表示要求构造的顺序...
  • 如果用一个循环数组表示队列,并且只设队列头指针Front,不设尾指针Rear,而是另设Count记录队列元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义: bool AddQ( Queue Q, ElementType X ); Element...
  • 数据结构与算法之循环队列的操作

    千次阅读 2019-10-13 21:12:44
    数据结构与算法之循环队列的操作 /* 循环队列的入队和出队算法设计 初始化循环队列 、打印队列、插入元素到循环队列、获取循环队列的首元素,元素不出队...循环队列出队, 队首循环后移: SQ->front =(SQ->fro...
  • c:循环队列

    2019-01-05 15:06:59
    c:循环队列 题目描述 根据给定的空间构造顺序循环队列,规定队满处理方法为少用一个元素空间。...输入的第一行为一自然数n,表示要求构造的顺序循环队列空间。第二行为操作次k,接下来k行为出队入...
  • 965: 循环队列

    2021-04-24 12:19:53
    题目描述 ...输入的第一行为一自然数n,表示要求构造的顺序循环队列空间。 第二行为操作次k,接下来k行为出队入队操作,每行各代表一次操作。入队用in表示,出队用out表示,如果是入队,则in隔一
  • 另类循环队列

    2021-03-06 14:38:10
    如果用一个循环数组表示队列,并且只设队列头指针Front,不设尾指针Rear,而是另设Count记录队列元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义: bool AddQ( Queue Q, ElementType X ); ...
  • C++ 循环队列

    2020-01-03 18:35:26
    因此,尽管队列中实际元素个数可能远远小于数组大小,但可能由于尾指针巳超出向量空间的上界而不能做入队操作。该现象称为假溢出。如下图所示是数组大小为5的顺序队列中队首、队尾指针和队列中元素的变化情况 为...
  • 编写一个程序,实现顺序循环队列的各种基本运算,完成如下功能 (1) 初始化队列 (2) 判断队列是否为空 (3) 依次进队元素a, b, c,d (4) 出队一个元素,输出该元素 (5) 输出队列的元素个数 (6) 依次进队列...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 259
精华内容 103
关键字:

循环队列出队元素个数