精华内容
下载资源
问答
  • #include<stdio.h> #include <stdlib.h> #define MaxQSize 7 typedef int ElemType; typedef struct{ ElemType *base; int rear; int length; }Queue; Queue InitQueue(){ ... Q.l
    #include<stdio.h>
    #include <stdlib.h>	
    #define MaxQSize	7
    typedef int ElemType;
    typedef struct{
    	ElemType *base;
    	int rear;
    	int length;
    }Queue;
    
    Queue InitQueue(){
    	Queue Q;
    	Q.base=(ElemType*)malloc(MaxQSize*sizeof(ElemType));
    	Q.rear=0;
    	Q.length=0;
    	return Q;
    }
    
    void EnQueue(Queue &Q,ElemType x){
    	if(Q.length==MaxQSize){                     
    		printf("队满"); 
    		exit(0);
    	} 
    	Q.base[Q.rear]=x;
    	Q.rear=(Q.rear+1)%MaxQSize;
    	Q.length++;
    }
    
    ElemType DeQueue(Queue &Q){
    	ElemType x;
    	if(Q.length==0) {                                  
    		printf("队空");
    		exit(0);
    	}
    	x=Q.base[(Q.rear+MaxQSize-Q.length+1)%MaxQSize];
    	Q.length--;
    	return x;
    }
    
    int main(){
    	Queue Q=InitQueue();
    	
    	char c[20];
    	int i,j;
    	printf("输入字符:\n");
    	scanf("%s",c);
    	for(i=0;c[i]!='\0';i++){
    		EnQueue(Q,c[i]);
    	}
    	
    	printf("%c ",DeQueue(Q));
    	printf("%c ",DeQueue(Q));
    	printf("%c ",DeQueue(Q));
    	printf("%c ",DeQueue(Q));
    	return 0; 
    	
    }
    

    调试:

    输入字符:
    acbdefg
    a c b d
    
    展开全文
  • 主要介绍了Java数据结构之循环队列简单定义与用法,简要描述了循环队列的概念、原理,并结合实例形式分析了java循环队列定义与使用方法,需要的朋友可以参考下
  • 1.顺序队列的常用基本操作及条件判断 队空: Q.front=Q.rear 队满: Q.rear=Maxlen 求队长: Q.rear-Q.front 入队: 1)新元素按 rear 指示位置加入 ...2.顺序队列的类型定义 #define ...

    1.顺序队列的常用基本操作及条件判断

    队空:    Q.front=Q.rear
     队满:    Q.rear=Maxlen
     求队长:  Q.rear-Q.front
    

    入队: 1)新元素按 rear 指示位置加入
    2)rear = rear + 1队尾指针加一
    出队: 1)将front指示的元素取出。
    2)front = front + 1队头指针加一
    2.顺序队列的类型定义

    #define MAXLEN 100
       typedef struct
        	{datatype  Q[MAXLEN];
        	  int front=0;
        	  int rear=0;
            } SeqQueue,*P;
    

    问:什么叫“假溢出” ?如何解决?
    答:在顺序队中,当尾指针已经到了数组的上界,不能再有入队操作,但其实数组中还有空位置,这就叫“假溢出”。
    解决假溢出的途径———采用循环列队

    循环队列

    想象为一个首尾相接的圆环,并称这种向量为循环向量,存储在其中的队列称为循环队列。在这里插入图片描述

    新问题:在循环队列中,空队特征是Q.front=Q.rear;队满时也会有Q.front=Q.rear;判决条件将出现二义性!
    解决方案有三:
    ①使用一个计数器记录队列中元素个数(即队列长度);
    ②加设标志位,删除时置1,插入时置0,则可识别当前Q.front=Q.rear属于何种情况
    ③ 人为浪费一个单元,则队满特征可改为Q.front=(Q.rear+1)%MAXLEN;

    实际中常选用方案3(人为浪费一个单元):
    即front和rear二者之一指向实元素,另一个指向空闲元素。

    队空条件 :  Q.front =Q. rear       (初始化时:Q.front = Q.rear )
    队满条件: Q.front = (Q.rear+1) % N         (N=maxsize)
    队列长度(即数据元素个数):L=(N+Q.rear-Q.front)% N
     
    

    在这里插入图片描述
    例1:数组Q[n]用来表示一个循环队列,f 为当前队列头元素的前一位置,r 为队尾元素的位置。假定队列中元素的个数小于n,计算队列中元素的公式为:
    A) r-f (B)(n+f-r)% n
    (C)n+r-f (D) (n+r-f)% n
    要分析4种公式哪种最合理?
    当 r ≥f 时(A)合理;
    当 r < f 时(C)合理; 综合2种情况,以(D)的表达最为合理
    例2:在一个循环队列中,若约定队首指针指向队首元素的前一个位置。那么,从循环队列中删除一个元素时,其操作是 先 移动队首指针,后取出元素
    在这里插入图片描述
    在这里插入图片描述

    怎样构成循环队列?
    在循环队列中进行出队、入队操作时,头尾指针仍要加1,朝前移动。
    只不过当头尾指针指向向量上界(MAXLEN-1)时,其加1操作的结果是指向向量的下界0。
    加1操作的结是指向向量的下界0的办法

    *(front+1)%M       (rear+1)%M*
    

    在这里插入图片描述

    队空:Q.front =Q. rear
    队满:Q.front =(Q.rear + 1) % MAXLEN
    入队: Q.rear = (Q.rear + 1) % MAXLEN
    出队: Q.front = (front + 1) % MAXLEN;
    求队长:(Q.rear-Q.front+ MAXLEN)% MAXLEN

    - 3)循环队列的类型定义

    #define MAXLEN 100
    typedef struct
    	{datatype *data[MAXLEN];
    	  int front;
    	  int rear;
         int n;/*判队空,队满的另一方法*/
       } CseqQueue
    

    - 4)循环队列操作的实现

    ①初始化队列

    CseqQueue * IniQueue (CseqQueue *Q) 
    {                                                    //构造空队列
      Q= (CseqQueue *) malloc(sizeof(CseqQueue ));
      Q->rear = Q->front = 0;
      return Q;
    }
    

    在这里插入图片描述
    ②判队空

    int QueueEmpty (CseqQueue *Q ) 
    {
        return(Q->rear == Q->front);
    }
    
    

    ③判队满

    int QueueFull (CseqQueue *Q ) 
    {
        return((Q->rear+1) % MAXLEN == Q->front);
    }
    

    ④判队满

    int QueueFull (CseqQueue *Q ) 
    {
        return( (Q->n) == MAXLEN);
    }
    

    ⑤入队

    int InQueue (CseqQueue *Q, datatype x ) 
    {
        if (QueueFull (Q) ) 
              return 0;
       else 
          {Q->data[Q->rear] = x; 
            Q->rear = ( Q->rear+1) % MAXLEN; 
            Q->n++;
            return 1;
          }
     }
    

    ⑥出队

    int DeQueue (CseqQueue *Q, datatype *x ) 
    {
        if ( QueueEmpty (Q) ) 
            return 0;
       else
           {*x = Q->data[Q->front]; 
             Q->front = ( Q->front+1) % MAXLEN; 
             Q->n--;
             return 1;
          }
    }
    

    ⑦取队头

    int GetFront (CseqQueue *Q, datatype *x ) 
    {
         if ( QueueEmpty (Q) )
              return 0;
         *x = Q->data[Q->front];
         return 1;
    }
    

    ⑧求队列长度

    int QueueLength (CseqQueue  *Q)
    {
      return( (Q->rear – Q->front + MAXSIZE) % MAXSIZE);
    }
    

    链队列结构

    (1)链队列结构**
    链队列示意图在这里插入图片描述
    (2)链队列的描述
    和顺序队列类似,我们也是将这两个指针封装在一起,将链队列的类型LinkQueue定义为一个结构类型:

    typedef struct queuenode
          { datatype  data;
             struct queuenode *next;
           }queuenode;
       typedef struct
          {  queuenode  *front;
              queuenode  *rear;
           }Linkqueue;
    

    3)链队列上实现的基本运算
    1)构造一个空队列(带头结点空队列)

      void initqueue(Linkqueue  *q)
         { q.front=(queuenode *)malloc(sizeof(queuenode));
           q.rear=q.front
           q.front->next=q.rear->next= NULL;
         }
    

    在这里插入图片描述
    2)入队操作
    在这里插入图片描述
    入队操作算法

    void inqueue(Linkqueue  *q,datatype  x)
         {queuenode *p
          p=(queuenode * )malloc(sizeof(queuenode));
          p–>data=x;
          p–>next=NULL;
          q.rear–>next=p;
          q.rear=p;
         }
    

    3)队列的判空

    int queueempty(Linkqueue  *q)
        {
          return (q.front->next= =NULL &&
                      q.rear->next= =NULL);
         }
    
    1. 出队操作在这里插入图片描述
      4)出队操作算法

    Datatype dequeue(Linkqueue *q)
    { datatype x;
    queuenode *p
    if(queueempty(q))
    { printf(“队列为空”); return;}
    p=q.front–>next;
    x=p–>data;
    q.front–>next=p–>next;
    if(q.rear = =p) /删除的是尾结点/
    q.rear=q.front;
    free§;
    return x;
    }

    有什么问题请留言 会及时修改的

    展开全文
  • 循环队列

    2018-05-03 22:43:10
    假设将循环队列定义为:以域变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。编写相应的入队列和出队列的程序,并判断循环队列是否队满(在出队列的算法中要返回队头元素)。假设队列数组为...

    假设将循环队列定义为:以域变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。编写相应的入队列和出队列的程序,并判断循环队列是否队满(在出队列的算法中要返回队头元素)。

    假设队列数组为Queue[MAXSIZE],第一行输入队列大小N,第二行开始输入若干入队元素,队满时,停止入队。第三行输入出队元素。

    输出入队出队操作后的循环队列,并返回出队元素的队头元素。

    5

    3 4 6 2 7

    4

    6 2 7

    6

    #include<iostream>
    #include<stdio.h>
    #include<stdlib.h>
    
    using namespace std;
    struct linklist
    {
    	struct linklist *next;
    	int data;
    };
    bool isdigi(char j)
    {
    	return (j >= '0' && j <= '9');
    }
    struct linkqueue
    {
    	struct linklist *rear;
    	struct linklist *head;
    	int length;
    }linq;
    void init()
    {
    	linq.length = 0;
    	linq.rear = NULL;
    }
    void popl()
    {
    	if(linq.head->next == linq.head)
    	{
    		linq.length = 0;
    		linq.rear = NULL;
    		linq.head = NULL;
    	}
    	else
    	{
    		linq.length--;
    		linq.rear->next = linq.head->next;
    		linq.head = linq.head->next;
    	}
    }
    void pushl(int x)
    {
    	struct linklist *newblock;
    	newblock = (struct linklist *)malloc(sizeof(struct linklist));
    	newblock->data = x;
    	if(linq.rear == NULL)
    	{
    		linq.rear = newblock;
    		linq.head = newblock;
    		linq.rear->next = linq.rear;
    	}
    	else
    	{
    		newblock->next = linq.head;
    		linq.rear->next = newblock;
    		linq.rear = newblock;
    	}
    	linq.length+=1;
    }
    int main()
    {
    	struct linklist *lq;
    	int num,data;
    	char m;
    	cin>>num;
    	init();
    	m = getchar();
    	m = getchar();
    	for(;m != '\n';)
    	{
    		if(isdigi(m) && linq.length < num)
    		{
    			pushl((int)(m-48));
    		}
    		m = getchar();
    	}
    	if(num <= linq.length)
    	{
    		getchar();
    		getchar();
    		getchar();
    		getchar();
    	}
    	else
    	{
    		getchar();
    		getchar();
    		getchar();
    	}
    	cin >> data;
    	for(;;)
    	{
    		if(linq.head->data != data)
    		{
    			popl();
    		}
    		else
    		{
    			popl();
    			break;
    		}
    	}
    	lq = linq.head;
    	if(lq == NULL)
    	{
    		cout<<endl;
    	}
    	else
    	{
    		for(;lq->next != linq.head;)
    		{
    			cout<< lq->data << ' ';
    			lq = lq->next;
    		}
    		cout<< lq->data <<endl;
    	}
    	if(lq == NULL)
    	{
    		cout<<endl;
    	}
    	else
    	{
    		cout<<linq.head->data<<endl;
    	}
    }

    展开全文
  • 顺序循环队列和链式队列的类定义和实现(C++).docx顺序循环队列和链式队列的类定义和实现(C++).docx
  • 顺序存储的队列,元素循环存储循环队列定义循环队列判空、判满循环队列长度代码实现测试结果 循环队列定义 在逻辑上把顺序存储的队列想象成一个环,就是循环队列。 循环队列仍是顺序存储,只是元素可以循环存储在...

    循环队列定义

    在逻辑上把顺序存储的队列想象成一个环,就是循环队列。
    循环队列仍是顺序存储,只是元素可以循环存储在给定的存储空间。

    前篇文章,顺序存储队列基本操作 所描述的队列的存储空间只可以使用一次,在一些元素出队之后,空出来的空间没有办法再次存储,造成浪费,所以更多选择循环队列。

    两者的内存中的存储一样,只是逻辑上将两者分为了非循环和循环。

    循环队列判空、判满

    判空和判满可以有多种方式,根据自己的设计选择即可。

    第一种方式:
    判空:当首尾指针指向同一位置时,队列为空。
    判满:当尾指针+1 = 首指针,队列已满。
    (这种方式是牺牲一个存储空间来判断队列是否已满)
    注意:判满时 需要对maxsize取余,否则rear可能超出maxsize。

    第二种方式:
    单独设置一个length变量,来存储队列的长度
    判空:length = 0
    判满:length = maxsize

    前篇文章,顺序存储队列基本操作 就是利用length判断长度

    第三种方式
    设置一个tag参数 tag=1 时队满;tag= 0 时对空。
    判空:当首尾指针指向同一位置时,队列为空。
    判满:tag=1 时队满;tag= 0 时对空。

    循环队列长度

    length = (rear + maxsize - front)%maxsize;

    代码实现

    /**
     * 循环队列的基本操作
     */
    #include <cstdio>
    
    #define maxsize 6  //定义队列中元素的最大个数
    /**
     * 定义结构
     */
    typedef struct {
        int data[maxsize];  //存放队列元素
        int front,rear;     //对头指针和队尾指针   数组下标也可以表示指针,可以不加*
    }SqQueue;
    
    /**
     * 初始化队列,构造一个空的队列
     */
    void initQueue(SqQueue &Q){
        Q.front = Q.rear = 0;   //初始化队首队尾指针,构建空的队列
    }
    /**
     * 判断队列是否为空
     */
    bool QueueIsEmpty(SqQueue Q){
        if(Q.front == Q.rear){  //队列为空
            printf("队列为空 \n");
            return true;
        }else{
            return false;
        }
    }
    /**
     * 入队操作
     * @param Q
     * @param value 入队的值
     */
    void enQueue(SqQueue &Q,int value){
        if(Q.front == (Q.rear + 1)%maxsize ){//判断队列是否已满
            printf("队列已满 \n");
            return;
        }
        Q.data[Q.rear] = value; //队尾指针指向新入队的数据
        Q.rear = (Q.rear+1)%maxsize;//rear指针+1 ,此处求余目的是不超出给定的maxsize
    }
    /**
     * 出队操作,返回出队元素
     * @param Q
     */
    int outQueue(SqQueue &Q){
        if(QueueIsEmpty(Q)){ //判断队列是否为空
            printf("队列为空 \n");
            return 0;
        }
        int x = Q.data[Q.front]; //要出队的元素
        Q.front = (Q.front+1)%maxsize;  //首指针后移一位
        return x;
    }
    /**
     * 读队头元素,并返回
     * @return
     */
     int getHead(SqQueue Q){
         return Q.data[Q.front];
     }
    /**
     * 创建完整队列
     * @param Q
     */
    void creatQueue(SqQueue &Q){
        //初始化
        initQueue(Q);
        
         int x;
         scanf("%d",&x);
         while(x != 9999){
             enQueue(Q,x);
             if(Q.front == (Q.rear + 1)%maxsize){
                 break;
             }
             scanf("%d",&x);
         }
    
     }
     /**
      * 打印
      * @return
      */
     void print(SqQueue Q){
         for (int i = Q.front; i < Q.rear; ++i) {
             printf("队列中存储的值 %d \n",Q.data[i]);
         }
         /**
          * 由于是循环存储数据,rear指针可能指向2的位置,
          * front指针指向5的位置(这种情况是尾指针跑到了首指针前面,会出现负数)
          * 负数不能取余,所以+maxsize,保证数据的正确,取余会把加的maxsize再去掉
          */
         int length = (Q.rear+maxsize - Q.front)%maxsize;
         printf("队列length %d \n",length);
      }
    int main(){
        SqQueue Q;
        printf("--------创建完整队列(入队)--------- \n");
        creatQueue(Q);
        printf("--------打印--------- \n");
        print(Q);
        printf("--------获取队头元素--------- \n");
        int head1 = getHead(Q);
        printf("队头元素 - %d \n",head1);
        printf("--------出队--------- \n");
        int out = outQueue(Q);
        printf("出队元素 - %d \n",out);
        printf("--------获取队头元素--------- \n");
        int head2 = getHead(Q);
        printf("队头元素 - %d \n",head2);
    
        return 0;
    }
    

    测试结果

    --------创建完整队列(入队)---------
    12
    13
    14
    15
    16
    17
    18
    9999
    --------打印---------
    队列中存储的值 12
    队列中存储的值 13
    队列中存储的值 14
    队列中存储的值 15
    队列中存储的值 16
    队列中存储的值 17
    队列中存储的值 18
    队列length 7
    --------获取队头元素---------
    队头元素 - 12
    --------出队---------
    出队元素 - 12
    --------获取队头元素---------
    队头元素 - 13
    
    

    顺序存储队列基本操作:https://blog.csdn.net/qq_35963993/article/details/106080380

    展开全文
  • 循环队列定义及操作

    千次阅读 2017-05-21 18:32:15
    #include #include #define MAXSIZE 50 typedef struct { int element[MAXSIZE]; int front; //队头指示器 int rear; //队尾指示器 } SeqQueue;...//初始化操作,将Q初始化为一个空的循环队列 bool En
  • 文章目录一,队列的定义二,循环队列定义结构代码初始化队列长度入队列出队列 一,队列的定义 队列是只允许在一端进行插入操作,而在另一端进行删除操作的线性表 队列是一种先进先出的线性表,简称FIFO ...
  • 顺序循环队列

    千次阅读 2019-01-08 08:49:52
    1.1 顺序循环队列定义  队列是一种运算受限的先进先出线性表,仅允许在队尾插入(入队),在队首删除(出队)。新元素入队后成为新的队尾元素,元素出队后其后继元素就成为队首元素。  队列的顺序存储结构使用一个...
  • 循环队列的基本定义 : 顺序存储结构定义: typedef struct{ QElemType *base; int Front,Rear; }CQueue;   循环队列的基本操作: 1、初始化一个队列 2、清空一个队列 3、判断一个队列是否为空 4、求...
  • 循环队列为充分利用向量空间,克服”假溢出”...循环队列的问题循环队列中,由于入队时尾指针向前追赶头指针;出队时头指针向前追赶尾指针,造成队空和队满时头尾指针均相等。因此,无法通过条件front==rear来判别队列
  • JAVA循环队列

    千次阅读 2017-09-15 15:25:44
    关于自定义循环队列的实现原理和要点可以参见之前的博文系列:循环队列及C语言实现。这里主要对JAVA下的具体实现方式与原理进行说明。 一、JAVA 中已经自带了 Queue、DQueue、ArrayList、LinkedList 等常用的数据...
  • 五、队列定义定义队列(queue):队列是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。队列是一种先进先出(First In First Out)的线性表,简称FIFO。允许插入操作的一端称为队尾,允许删除操作...
  • 队列实现循环队列

    千次阅读 2018-04-20 21:53:40
    二、实验内容仿照资料中顺序循环队列的例子,设计一个只使用队头指针和计数器的顺序循环队列抽象数据类型。其中操作包括:初始化、入队列、出队列、判断队列是否非空。编写主函数,验证所设计的顺序循环队列的正确性...
  • 循环队列(严3.30)

    千次阅读 2018-04-13 15:47:23
    Description假设将循环队列定义为:以域变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。编写相应的入队列和出队列的程序,并判断循环队列是否队满(在出队列的算法中要返回队头元素)。Input第...
  • 循环队列是用一个数组来实现队列,是对原来基础上的一个优化 初始front=rear=-1,front表示队列的最前端的前一个位置,rear表示队列的最后一个位置 循环队列可以使得数组中的每一个空间都被充分利用 循环队列中的...
  • 数据结构习题——9循环队列

    千次阅读 2018-08-29 11:47:20
    假设将循环队列定义为:以域变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。编写相应的入队列和出队列的程序,并判断循环队列是否队满(在出队列的算法中要返回队头...
  • 假设将循环队列定义为:以与变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。试给出此循环队列的队满条件,并写出相应的入队列和出队列的算法(在出队列的算法中要返回队头元素)。 输入: 先...
  • 循环队列–C语言实现–数据结构

    万次阅读 多人点赞 2017-06-22 16:36:45
    循环队列–C语言实现–数据结构目录循环队列C语言实现数据结构目录 一 要求 二 循环队列循环队列的算法设计 1 建立循环队列 2 置空队列 3 入队 4 出队 5 打印队 四 程序 1 程序的结构 2 程序源码 五 程序测试 1 ...
  • 主要介绍了JavaScript数据结构之优先队列与循环队列,结合实例形式较为详细的分析了javascrip数据结构中优先队列与循环队列的原理、定义与使用方法,需要的朋友可以参考下
  • C语言实现循环队列

    千次阅读 多人点赞 2020-06-24 15:58:46
    详解循环队列的巧妙之处
  • 思路:首先得定义一个循环队列,循环队列定义如下: 设front为队首,rear为队尾,Q指向malloc分配的动态数组,n为元素个数 入队: rear=(rear+1)%n; Q[rear]=入队元素; 队满不可入队:(rear+1)%n=front; 出队...
  • 循环队列是对队列的一种改进,它比队列适用的范围更广,例如Linux内核当中的环形缓冲区就是基于循环队列来设计的。本文主要任务是通过C语言来实现一个循环队列的数据结构,以及对循环队列的基本操作。 1、循
  • C语言——循环队列

    千次阅读 2018-12-26 20:20:46
    循环队列 遵循先进先出(FIFO) 浪费一个空间,让循环队列更好的判断满/空,更好运用循环队列 黑色代表空时状态,红色代表满时状态 下面代码: #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 224,775
精华内容 89,910
关键字:

循环队列的定义