精华内容
下载资源
问答
  • 准备写队列以下几种类型:循环队列(顺序结构),链队列,循环队列(只有尾指针),字符队列(顺序结构) 一、循环队列循环队列存储结构typedef int QElemType; typedef struct{ QElemType *base; int front; int...

    准备写队列以下几种类型:循环队列(顺序结构),链队列,循环队列(只有尾指针),字符队列(顺序结构)


    一、循环队列

    循环队列存储结构

    typedef int QElemType;
    typedef struct{
        QElemType *base;
        int front;
        int rear;
    }SqQueue;
    

    实现循环语句

    可以把循环队列想象成一个圈

    这里写图片描述

    因为循环队列假如是数据能占所有位置,那么队满或者对空的语句都是front==rear,这样就不能判断了,所以需要空出一个位置出来即mansize-1个位置

    插入队列实现循环语句:Q.rear=(Q.rear+1)%maxsize;

    删除队头实现循环语句:Q.front=(Q.front+1)%maxsize;

    判断队列满:(Q.rear+1)%maxsize==Q,front;

    判空:Q.front==Q.rear;

    注意:Q.front和Q.rear是指下标,例如取第一个元素值:Q.base[Q.front];

    demo

    #include <stdio.h>
    #define Maxsize 100
    typedef int QElemType;
    typedef struct{
        QElemType *base;
        int front;
        int rear;
    }SqQueue;
    int count=0;
    SqQueue QueueInit(SqQueue s)
    {
        s.base=(QElemType *)malloc(Maxsize*sizeof(QElemType));
        if(!s.base)
            printf("error");
        else{
            s.front=s.rear=0;
        }
        return s;
    }
    
    SqQueue InsertQueue(SqQueue s,QElemType e)
    {
        if((s.rear+1)%Maxsize==s.front)
            printf("error");
        else{
            s.base[s.rear]=e;
            s.rear=(s.rear+1)%Maxsize;
        }
        count++;
        return s;
    }
    
    SqQueue OutQueue(SqQueue s)
    {
        int e;
        if(s.rear==s.front)
            printf("error");
        else{
            e=s.base[s.front];
            s.front=(s.front+1)%Maxsize;
        }
        printf("%d",e);
        count--;
        return s;
    }
    
    int main()
    {
        SqQueue s,p;
        int e,i;
        s=QueueInit(s);
        for(i=0;i<4;i++)
        {
            s=InsertQueue(s,i+1);
        }
        p=s;
        for(i=0;i<count;i++)
        {
            printf("%d ",p.base[p.front]);
            p.front=(p.front+1)%Maxsize;
        }
        printf("\n");
        s=OutQueue(s);
        printf("\n");
        p=s;
        for(i=0;i<count;i++)
        {
            printf("%d ",p.base[p.front]);
            p.front=(p.front+1)%Maxsize;
        }
        return 0;
    }
    

    二、链队列

    存储结构

    typedef int QElemType;
    typedef struct QLNode{
        QElemType data;
        struct QLNode *next;
    }QNode,*QueuePtr;
    
    typedef struct{
        QueuePtr front;
        QueuePtr rear;
    }LinkQueue;
    

    demo

    #include <stdio.h>
    #include <malloc.h>
    typedef int QElemType;
    typedef struct QLNode{
        QElemType data;
        struct QLNode *next;
    }QNode,*QueuePtr;
    
    typedef struct{
        QueuePtr front;
        QueuePtr rear;
    }LinkQueue;
    
    void InitQueue(LinkQueue *Q)
    {   //printf("ss");
        Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
       // printf("ss");
        Q->front->next=NULL;
    }
    
    void InsertQueue(LinkQueue *Q,int e)
    {
        QueuePtr p;
        p=(QueuePtr)malloc(sizeof(QNode));
        p->data=e;
        p->next=NULL;
        Q->rear->next=p;
        Q->rear=p;
    
    }
    
    void OutQueue(LinkQueue *Q)
    {
        QueuePtr p;
        int e;
        if(Q->front==Q->rear)
            printf("error");
        p=Q->front->next;
        e=p->data;
        Q->front->next=p->next;
        printf("%d",e);
        if(Q->rear==p)
            Q->rear=Q->front;
        free(p);
    
    }
    
    int main()
    {
        LinkQueue Q;
        QueuePtr p;
        int i;
        //printf("s");
        InitQueue(&Q);
        //printf("s");
        for(i=0;i<4;i++)
        {
            InsertQueue(&Q,i+1);
        }
       // printf("s");
        p=Q.front->next;
        for(i=0;i<4;i++)
        {
            printf("%d ",p->data);
            p=p->next;
        }
        printf("\n");
        OutQueue(&Q);
        printf("\n");
        p=Q.front->next;
         for(i=0;i<3;i++)
        {
            printf("%d ",p->data);
            p=p->next;
        }
        return 0;
    }
    

    三、循环队列(只有尾指针)

    这个问题即用链式存储结构

    存储结构

    typedef int QElemType;
    typedef struct Lnode{
        int data;
        struct Lnode *next;
    }Node,*SqQueue;
    

    demo

    #include <stdio.h>
    #include <malloc.h>
    #define Maxsize 100
    typedef int QElemType;
    typedef struct Lnode{
        int data;
        struct Lnode *next;
    }Node,*SqQueue;
    int count=0;
    SqQueue QueueInit(SqQueue rear)
    {
        rear=(SqQueue)malloc(sizeof(Node));
        if(!rear)
            printf("error");
        else{
            rear->next=rear;
        }
        return rear;
    }
    
    SqQueue InsertQueue(SqQueue rear,QElemType e)
    {
        SqQueue p;
        p=(SqQueue)malloc(sizeof(Node));
        p->data=e;
        p->next=rear->next;
        rear->next=p;
        rear=p;
        count++;
        return rear;
    }
    
    SqQueue OutQueue(SqQueue rear)
    {
        int e;
        SqQueue p;
        if(rear==rear->next)
            printf("error");
        else{
            p=rear->next->next;
            e=p->data;
            rear->next->next=p->next;
            if(rear==p)
            {
                rear=rear->next;
            }
            free(p);
        }
        printf("%d",e);
        count--;
        return rear;
    }
    
    int main()
    {
        SqQueue rear,p,q;
        int e,i;
        rear=QueueInit(rear);
        for(i=0;i<4;i++)
        {
            rear=InsertQueue(rear,i+1);
        }
        p=rear->next->next;
        for(i=0;i<4;i++)
        {
            printf("%d ",p->data);
            p=p->next;
        }
        printf("\n");
        rear=OutQueue(rear);
        printf("\n");
        q=rear->next->next;
        for(i=0;i<3;i++)
        {
            printf("%d ",q->data);
            q=q->next;
        }
        return 0;
    }
    

    四、字符队列(顺序结构)

    字符队列和普通没什么区别,但最重要一点就是字符输入时,会把空格或回车也放入缓存区,导致我想输入4个字符,却只能输入两个,解决办法就是加getchar();


    demo

    #include <stdio.h>
    #define Maxsize 1000
    typedef char QElemType;
    typedef struct{
        QElemType *base;
        int front;
        int rear;
    }SqQueue;
    int count=0;
    SqQueue QueueInit(SqQueue s)
    {
        s.base=(QElemType *)malloc(Maxsize*sizeof(QElemType));
        if(!s.base)
            printf("error");
        else{
            s.front=s.rear=0;
        }
        return s;
    }
    
    SqQueue InsertQueue(SqQueue s,QElemType e)
    {
        if((s.rear+1)%Maxsize==s.front)
            printf("error");
        else{
            s.base[s.rear]=e;
            s.rear=(s.rear+1)%Maxsize;
            count++;
        }
    
        return s;
    }
    
    SqQueue OutQueue(SqQueue s)
    {
        char e;
        if(s.rear==s.front)
            printf("error");
        else{
            e=s.base[s.front];
            s.front=(s.front+1)%Maxsize;
            count--;
        }
        printf("%c",e);
        return s;
    }
    int main()
    {
        SqQueue s,p;
        char a;
        int i;
        int l;
    
        s=QueueInit(s);
        for(l=0;l<4;l++)
        {
            scanf("%c",&a);
            getchar();//注意
            s=InsertQueue(s,a);
        }
        p=s;
        for(i=0;i<4;i++)
        {
            printf("%c",p.base[p.front]);
            p.front=(p.front+1)%Maxsize;
        }
        return 0;
    }
    
    展开全文
  • 循环队列和链式结构队列

    千次阅读 2017-02-27 13:22:04
    一、循环队列的基础知识 1,循环队列有几个参数需要确定:  有两个参数,front和rear 2,循环队列各个参数的含义 (1)队列初始化时,front和rear值都为零; (2)当队列不为空时,front指向队列的第一...

    一、循环队列的基础知识

    1,循环队列有几个参数需要确定:
          有两个参数,front和rear
    2,循环队列各个参数的含义

    (1)队列初始化时,front和rear值都为零;

    (2)当队列不为空时,front指向队列的第一个元素,rear指向队列最后一个元素的下一个位置;

    (3)当队列为空时,front与rear的值相等,但不一定为零;

    3.循环队列入队的伪算法

    (1)把值存在rear所在的位置;

    (2)rear=(rear+1)%maxsize ,其中maxsize代表数组的长度;

    4.循环队列出队的伪算法

    (1)先保存出队的值;

    (2)front=(front+1)%maxsize ,其中maxsize代表数组的长度;

    5.如何判断循环队列是否为空

    if(front==rear)

    队列空;

    else

    队列不空

    6.如何判断循环队列是否为满


     这个问题比较复杂,假设数组的存数空间为7,此时已经存放1,a,5,7,22,90六个元素了,如果在往数组中添加一个元素,则rear=front;此时,队列满与队列空的判断条件front=rear相同,这样的话我们就不能判断队列到底是空还是满了;

    解决这个问题有两个办法:一是增加一个参数,用来记录数组中当前元素的个数;第二个办法是,少用一个存储空间,也就是数组的最后一个存数空间不用,当(rear+1)%maxsiz=front时,队列满;

    参考代码:
    #include<stdio.h>
    #include<malloc.h>
    #include<stdbool.h>
    typedef struct Queue {
    	int * PBase;//指向数组第一个元素的指针
    	int front;//队列头部元素下标
    	int rear;//队列尾部元素下标
    }QUEUE;
    /**
    *初始化队列,实现队列的数组长度为6。
    **/
    void initQueue(QUEUE * pQ)
    {
    	pQ->PBase = malloc(sizeof(int) * 6);
    	pQ->front = 0;
    	pQ->rear = 0;
    }
    /**
    判断队列是否已满
    */
    bool isFull(QUEUE * pQ)
    {
    	if ((pQ->rear + 1) % 6 == pQ->front)
    	{
    		printf("队列已满,无法插入");
    		return true;
    	}
    
    	return false;
    }
    
    /**
    判断队列是否为空
    */
    
    bool isEmpty(QUEUE * pQ)
    {
    	if (pQ->front == pQ->rear)
    	{
    		printf("队列为空");
    		return true;
    	}
    	return false;
    }
    /**
    入队
    */
    bool insert(QUEUE * pQ, int val)
    {
    	if (isFull(pQ))
    		return false;
    	pQ->PBase[pQ->rear] = val;
    	pQ->rear = (pQ->rear + 1) % 6;
    	return true;
    }
    
    /**
    遍历队列
    */
    
    void traverse(QUEUE * pQ)
    {
    	int i = pQ->front;
    	while (i != pQ->rear)
    	{
    		printf("%d  ", pQ->PBase[i]);
    		i++;
    	}
    	printf("\n");
    }
    
    /**
    出队
    */
    
    bool  out_queue(QUEUE * pQ)
    {
    	if (isEmpty(pQ))
    		return false;
    	pQ->front = (pQ->front + 1) % 6;
    
    }
    
    int main()
    {
    
    	QUEUE Q;
    	initQueue(&Q);
    	insert(&Q, 1);
    	insert(&Q, 2);
    	insert(&Q, 3);
    	insert(&Q, 4);
    	insert(&Q, 5);
    	insert(&Q, 6);
    	traverse(&Q);
    	out_queue(&Q);
    	traverse(&Q);
    	return 0;
    }


    二、链式队列

    #include<stdio.h>  
    #include<stdlib.h>  
    #include<malloc.h>  
    typedef int Item;
    typedef struct node *PNode;
    #define num 5  
    typedef struct node
    {
    	Item data;
    	PNode next;
    }Node;
    
    typedef struct queue *PQueue;
    
    typedef struct queue
    {
    	PNode front;
    	PNode rear;
    	Item size;
    }Queue;
    
    /***创建空队列***/
    PQueue Creat_Queue();
    
    /***判断队列是否为空***/
    int Is_Empty(PQueue);
    
    PQueue CreateQueue(PQueue); //创建队列    
    
    
    							/***数据项入队,在队尾入队***/
    PQueue Add_Queue(PQueue, Item);
    
    /***计算队列大小***/
    int Size_Queue(PQueue);
    
    /***数据项出队,在队首出队***/
    Item Delete_Queue(PQueue);
    
    /***清空队列***/
    void Clear_Queue(PQueue);
    
    /***遍历队列***/
    void Traverse_Queue(PQueue);
    
    /***创建空队列***/
    PQueue Creat_Queue()
    {
    	PQueue P = (PQueue)malloc(sizeof(Queue));
    	P->rear = P->front = (PNode)malloc(sizeof(Node));
    	if (NULL == P || NULL == P->front)
    	{
    		printf("The queue is failed.\n");
    		exit(1);
    	}
    	//P->front=P->rear;  
    	P->front->next = NULL;
    	P->size = 0;
    	return P;
    }
    
    /***判断队列是否为空***/
    int Is_Empty(PQueue P)
    {
    	if (P->front == P->rear)
    		return 1;
    	else
    		return 0;
    }
    
    PQueue CreateQueue(PQueue P) //创建队列    
    {
    	P = Creat_Queue();
    	printf("Enter the data:");
    	int k;
    	while ((scanf_s("%d", &k)) == 1)
    	{
    		Add_Queue(P, k);
    		printf("Enter the next data:");
    	}
    	return P;
    }
    
    /***数据项入队,在队尾入队***/
    PQueue Add_Queue(PQueue P, Item data)
    {
    	PNode temp = (PNode)malloc(sizeof(Node));
    	if (NULL == temp)
    	{
    		printf("The temp is failed.\n");
    		exit(1);
    	}
    	temp->data = data;
    	temp->next = NULL;
    	if (Is_Empty(P))
    		P->front->next = temp;
    	else
    		P->rear->next = temp;
    	P->rear = temp;
    	P->size++;
    	printf("Add the data of %d to queue is success: %d\n ", data, data);
    	return P;
    }
    
    /***计算队列大小***/
    int Size_Queue(PQueue P)
    {
    	return P->size;
    }
    
    /***数据项出队,在队首出队***/
    Item Delete_Queue(PQueue P)
    {
    	Item data;
    	if (Is_Empty(P))
    		return NULL;
    	PNode temp = P->front->next;
    	data = temp->data;
    	P->front->next = temp->next;
    	if (0 == P->size)
    		P->rear = P->front;
    	P->size--;
    	free(temp);
    	return data;
    }
    
    /***清空队列***/
    void Clear_Queue(PQueue P)
    {
    	PNode temp = P->front->next;
    	while (temp)
    	{
    		PNode tp = temp;
    		temp = temp->next;
    		free(tp);
    	}
    	temp = P->front;
    	P->front = P->rear = NULL;
    	free(temp);
    }
    
    /***遍历队列***/
    void Traverse_Queue(PQueue P)
    {
    	if (Is_Empty(P))
    		printf("there is no data in the queue!\n");
    	else
    	{
    		PNode pCurrent = P->front->next;
    		printf("Now datas int the queue are:\n");
    		while (pCurrent)
    		{
    			printf("%d ", pCurrent->data);
    			pCurrent = pCurrent->next;
    		}
    		printf("\n");
    	}
    	return;
    }
    
    int main()
    {
    
    	/***创建空队列***/
    	PQueue PQ;
    	int size = 0;
    	int data;
    	PQ = Creat_Queue();
    	printf("The queue is created.\n");
    
    	/***判断队列是否为空***/
    	if (Is_Empty(PQ))
    		printf("The queue is empty.\n");
    
    	PQ = CreateQueue(PQ); //创建队列  
    						  /***遍历队列***/
    	Traverse_Queue(PQ);
    
    	/***数据项入队,在队尾入队***/
    	PQ = Add_Queue(PQ, num);
    	/***遍历队列***/
    	Traverse_Queue(PQ);
    
    	/***计算队列大小***/
    	size = Size_Queue(PQ);
    	printf("The size of queue are: %d\n", size);
    
    	/***数据项出队,在队首出队***/
    	data = Delete_Queue(PQ);
    	printf("The deleted data is: %d\n", data);
    	/***遍历队列***/
    	Traverse_Queue(PQ);
    
    	/***清空队列***/
    	Clear_Queue(PQ);
    	if (Is_Empty(PQ))
    		printf("The queue is empty.\n");
    	/***遍历队列***/
    	Traverse_Queue(PQ);
    
    	return 0;
    }
    




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

    2014-03-20 23:20:41
    循环队列数据结构.循环队列的基本操作实现算法,特别注意队满和队空的描述方法
  • 数据结构-循环队列

    2017-10-19 22:50:46
    数据结构顺序存储循环队列,数据结构顺序存储循环队列
  • 循环队列–C语言实现–数据结构

    万次阅读 多人点赞 2017-06-22 16:36:45
    循环队列–C语言实现–数据结构目录循环队列C语言实现数据结构目录 一 要求 二 循环队列循环队列的算法设计 1 建立循环队列 2 置空队列 3 入队 4 出队 5 打印队 四 程序 1 程序的结构 2 程序源码 五 程序测试 1 ...

    循环队列–C语言实现–数据结构


    目录


    (一) 要求

    假设以数组sequ[m]存放循环队列的元素,同时设变量rear和quelen 分别指示循环队列中队尾元素的位置和内含元素的个数。编写实现该循环队列的入队和出队操作的算法。提示:队空的条件:sq->quelen==0;队满的条件:sq->quelen==m。


    (二) 循环队列

    定义:为充分利用向量空间,克服”假溢出”现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表的方式来在实际编程应用中来实现, 当然也可以利用顺序表来实现。顺序表就是我们熟悉的数组 eg. sun[]
    回顾:我们再来回顾一下关于顺序队列的重要知识点。队列通常与栈对应,栈是一种后进先出的单端(尾端)处理的数据结构;那么与之对应的队列是一种先进先出的双端(头尾两端)的数据结构。队列的特点就是在一段进行入队(存储数据)操作,在另一端进行出队(删除数据)操作。
    为什么设计循环队列:大家在处理队列的时候,会遇到如下情况。例如说:我们的队列空间能够容纳1000个元素。首先,格格入队1000个元素,队列上溢,此时为“真溢出”。那么现在我们进行出队操作,我们一直出队,一直出队, 知道1000个元素全部被删除,此时我们发现队列仍然处于“上溢”状态,why? 其实原因很简单,在非循环队列当中,无论我们的front指(偏移)到哪里,只要我们的rear指(偏移)向上阙,那么队列就是“满溢”的。这就造成了空间明明还被占据着,但是队列却已经无用武之地的窘境。对于空间有限的计算机来说,这无疑是一种浪费。也不是一个优秀的程序猿想要看到的。所以在这种情况下,循环队列诞生了。循环队列当中的“满溢”只有一种情况,那就是所有数据空降都被占领了。而不会存在非循环队列当中的“假溢出”现象。


    我们所常见的顺序循环队列通常有两种数据结构。

    结构一

    typedef struct
    {
        datatype sequ[m];
        //sequ[]为我们所建立的顺序表(sequence)
        int  front,rear;
        //front表示队列头的偏移量,rear表示队列的尾的偏移量
    }qu;//qu是队列(queue)的缩写

    这里写图片描述

    结构二

    typedef struct
    {
        datatype sequ[m];
        //sequ[]为我们所建立的顺序表(sequence)
        int  rear, quelen;
        //rear表示队列的尾的偏移量,quelen表示的是队列中元素的个数
    }qu;//qu是队列(queue)的缩写

    那通过观察这两种机构我们能够很容易的发现,数据结构并不是固定的。我们觉得那种算法比较更合理,我们觉得哪种数据结构方便我们设计算法,那么我们就建立哪种数据结构。在本文当中,我们采用第二种数据结构。显而易见的是,当我们采用第二种数据结构时,我们建立的一个队列指针(qu*sq)队空的条件:sq->quelen==0;队满的条件:sq->quelen==m。


    (三) 循环队列的算法设计


    在上面我们了解了循环队列的数据机构,但是仅仅学会了数据结构还远远不够。我们设计数据结构的目的是为了更好的存储数据,并利用数据。下面我们来看一看关于循环队列我们要掌握哪些最基本的算法(利用数据机构)。


    3.1 建立循环队列

    //建立队
    qu* creatqueue();//函数声明
    qu* creatqueue()//函数实现
    {
        qu *sq;
        sq=(qu*)malloc(sizeof(qu));
        return sq;  
    }

    3.2 置空队列

    //置空队
    void setnull(qu*);//函数声明
    void setnull(qu *sq)//函数实现
    {
        sq->rear = m - 1;
        sq->quelen = 0;
    }

    3.3 入队

    //入队
    void enqueue(qu*, datatype);//函数声明
    void enqueue(qu*sq, datatype x)//函数实现
    {
        if (sq->quelen == 5)
            printf("Errot! The queue will be overflow! \n");
        else if((sq->rear+1)==m)
        {
            sq->rear = (sq->rear + 1) % m;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("过5入队成功!\n");
        }
        else
        {
            sq->rear++;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("入队成功!\n");
        }
    }

    **算法流程图**


    3.4 出队

    //出队
    datatype *dequeue(qu*);//函数声明
    datatype *dequeue(qu*sq)//函数实现
    {
        datatype sun=0;
        if (sq->quelen == 0)
        {
            printf("Error! The queue will be under flow!\n");
            return 0;
        }
        else if ((sq->rear + 1) >= sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen];
            return(&sun);
        }
        else    //  if(sq->rear < sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen + m];
            return(&sun);
        }
    }
    

    **算法流程图**


    3.5 打印队

    //打印队
    void print(qu*);//函数声明
    void print(qu*sq)//函数定义
    {
        if (sq->quelen == 0)
            printf("Error! The queue is Null!\n");
        else if ((sq->rear + 1) >= sq->quelen)
        {
            int i = sq->rear + 1 - sq->quelen;
            for (i; i <= sq->rear; i++)
                printf("%d   ", sq->sequ[i]);
        }
        else
        {
            int t = sq->rear - sq->quelen + m +1;
            int time = 1;
            for (t; time <= (sq->quelen); time++)
            {
                printf("%d   ", sq->sequ[t]);
                t++;
                if (t == m)
                {
                    t = 0;
                    continue;
                }
                else
                {
                    continue;
                }
            }
        }
        printf("\n");
    }

    (四) 程序


    下面我们来设计一个程序测试我们的数据机构与算法


    4.1 程序的结构

    **程序结构**


    4.2 程序源码

    注意:该程序由Microsoft Visual Studio Enterprise 2015编译器进行调试。受制于编译器品牌及版本不同等不可抗因素造成的编译失败,请自行调整。

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #define m 5
    
    //循环队列的结构类型定义
    typedef int datatype;
    typedef struct
    {
        datatype sequ[m];
        int  rear, quelen;
    }qu;
    
    //函数声明
    qu* creatqueue();
    void setnull(qu*);
    void enqueue(qu*, datatype);
    datatype *dequeue(qu*);
    void print(qu*);
    
    //主函数
    void main()
    {
        qu *sq= creatqueue();
    
        datatype x, *p;
        int key;
    
        setnull(sq);
        do
        {
            printf("1.Enter Queue   2.Delete Queue   3.clc display   4.print queue   -1.Quit:");
            scanf_s("%d", &key);
            switch (key)
            {
            case 1:  printf("Enter the Data:"); scanf_s("%d", &x);
                enqueue(sq, x);  break;
            case 2:  p = dequeue(sq);
                if (p != NULL) printf("%d\n", *p);
                break;
            case 3:system("cls"); break;
            case 4:print(sq); break;
            case -1: exit(0);
            }
        } while (1);
    }
    
    //建立队
    qu* creatqueue()
    {
        qu *sq;
        sq=(qu*)malloc(sizeof(qu));
        return sq;  
    }
    //置空队
    void setnull(qu *sq)
    {
        sq->rear = m - 1;
        sq->quelen = 0;
    }
    
    //入队
    void enqueue(qu*sq, datatype x)
    {
        if (sq->quelen == 5)
            printf("Errot! The queue will be overflow! \n");
        else if((sq->rear+1)==m)
        {
            sq->rear = (sq->rear + 1) % m;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("过5入队成功!\n");
        }
        else
        {
            sq->rear++;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("入队成功!\n");
        }
    }
    
    
    //出队
    datatype *dequeue(qu*sq)
    {
        datatype sun=0;
        if (sq->quelen == 0)
        {
            printf("Error! The queue will be under flow!\n");
            return 0;
        }
        else if ((sq->rear + 1) >= sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen];
            return(&sun);
        }
        else    //  if(sq->rear < sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen + m];
            return(&sun);
        }
    }
    
    //打印队列
    void print(qu*sq)
    {
        if (sq->quelen == 0)
            printf("Error! The queue is Null!\n");
        else if ((sq->rear + 1) >= sq->quelen)
        {
            int i = sq->rear + 1 - sq->quelen;
            for (i; i <= sq->rear; i++)
                printf("%d   ", sq->sequ[i]);
        }
        else
        {
            int t = sq->rear - sq->quelen + m +1;
            int time = 1;
            for (t; time <= (sq->quelen); time++)
            {
                printf("%d   ", sq->sequ[t]);
                t++;
                if (t == m)
                {
                    t = 0;
                    continue;
                }
                else
                {
                    continue;
                }
            }
        }
        printf("\n");
    }
    
    

    (五) 程序测试


    5.1 入队列

    **入队列及上溢检测**


    5.2 出队列

    出队列及下溢检测


    5.3 打印队列

    前面已经用到了打印队列,所以格格不再赘述,大家由5.2&5.3可知打印队列是成功的。


    (六) 源程序及封装软件下载

    下载地址


    格格是一枚智能专业的本科在校生,很愿意和各位大佬交流。如果大家有愿意交朋友的,可以加格格的QQ:446019725,声明是CSDN即可。



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

    2014-08-15 09:53:34
    本程序用C语言实现了循环队列的一些基本操作,适于C语言初学者做一些参考。
  • 数据结构的作业,只有尾指针的循环队列,可以入队出队打印等
  • 数据结构循环队列.CPP

    2020-12-24 13:02:43
    循环队列
  • 数据结构循环队列

    千次阅读 2019-03-06 15:35:54
    数据结构循环队列 前言: 关于循环队列需明白以下几点: 1、循环队列是队列的顺序存储结构 2、循环队列用判断是否为空利用 Q.front=Q.rear 3、循环队列头指针始终指向队列头元素,而尾指针始终指向队列尾元素的下...

    数据结构之循环队列

    前言:
    关于循环队列需明白以下几点:
    1、循环队列是队列的顺序存储结构
    2、循环队列用判断是否为空利用 Q.front=Q.rear
    3、循环队列头指针始终指向队列头元素,而尾指针始终指向队列尾元素的下一个位置
    4、按照队列的定义,队头删除,队尾插入,在这里插入图片描述会导致队头之前可能有空余的内存空间(如下图J1,J2出队后,空间被浪费),为了解决该问题,提出循环队列的解决方案
    在这里插入图片描述
    5、循环队列通过浪费一个空间,利用(Q.rear+1)%maxSize=Q.front判断队列是否为满,以此解决队列空间浪费问题(如下图所示)
    在这里插入图片描述
    一、循环队列的基本操作的实现代码

    // 循环队列.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include "stdio.h"
    #include "stdlib.h"
    
    #define  maxQueueSize 5 //事先确定的最大队列长度
    
    typedef int QElemType;
    
    typedef struct
    {
    	QElemType *base;//初始化动态分配的指定长度的空间
    	int front;//头指针,若队列不空,指向队列头元素
    	int rear;//尾指针,若多列不空,指向队列尾元素的下一个位置
    }SqQueue;
    
    /*循环队列初始化*/
    bool InitQueue(SqQueue *Q)
    {
    	Q->base=(QElemType*)malloc(maxQueueSize*sizeof(QElemType));
    	if (!Q->base)
    	{
    		return false;
    	}
    	Q->front=0;
    	Q->rear=0;
    	printf("循环队列初始化完成!\n");
    	return true;
    }
    
    /*循环队列入队*/
    bool EnQueue(SqQueue *Q,QElemType e)
    {
    	if ((Q->rear+1)%maxQueueSize==Q->front)//队列满
    	{
    		return false;
    	}
    	Q->base[Q->rear]=e;
    	Q->rear=(Q->rear+1)%maxQueueSize;
    	printf("%d 入队完成!\n",e);
    	return true;
    }
    
    /*循环队列出队*/
    bool DeQueue(SqQueue *Q,QElemType *e)
    {
    	if (Q->front==Q->rear)//队列空
    	{
    		return false;
    	}
    	*e=Q->base[Q->front];
    	Q->front=(Q->front+1)%maxQueueSize;
    	printf("%d 出队完成!\n",*e);
    	return true;
    }
    
    /*打印循环队列*/
    void printfQueue(SqQueue Q)
    {
    	printf("打印循环队列如下\n");
    	while (Q.front!=Q.rear)
    	{
    		if (Q.front==maxQueueSize &&(Q.rear+1)%maxQueueSize!=Q.front)
    		{
    			Q.front=0;
    		}
    		printf("%d ",Q.base[Q.front]);
    		Q.front++;
    	}
    	printf("\n");
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	SqQueue *Q=(SqQueue*)malloc(sizeof(SqQueue));
    	InitQueue(Q);
    
    	EnQueue(Q,6);
    	EnQueue(Q,8);
    	EnQueue(Q,10);
    	EnQueue(Q,12);
    	printfQueue(*Q);
    	QElemType *e=(QElemType*)malloc(sizeof(QElemType));
    	DeQueue(Q,e);
    	DeQueue(Q,e);
    	EnQueue(Q,14);
    	EnQueue(Q,16);
    	printfQueue(*Q);
    
    	system("pause");
    	return 0;
    }
    

    循环队列运行过程图如下:
    在这里插入图片描述
    程序实际运行结果如下,对比上面出队入队图,也就对循环队列有了更深的理解:
    在这里插入图片描述

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

    2013-04-27 23:11:53
    c++ 数据结构循环队列的基本操作 插入 删除 插入
  • 数据结构循环队列的C语言实现
  • 主要介绍了JavaScript数据结构之优先队列与循环队列,结合实例形式较为详细的分析了javascrip数据结构中优先队列与循环队列的原理、定义与使用方法,需要的朋友可以参考下
  • 数据结构作业之七循环队列,数据结构作业之七循环队列,数据结构作业之七循环队列
  • 循环队列

    2020-03-13 22:56:22
    文章目录循环队列(一) 要求(二)循环队列结构一结构二(三) 循环队列的算法设计3.1 建立循环队列3.2 置空队列3.3 入队3.4 出队3.5 打印队3.6 完整代码 循环队列 (一) 要求 假设以数组sequ[m]存放循环队列的元素...
  • 淮海工学院计算机科学系 实验报告书 课程名 数据结构 题 目 数据结构实验 链队列和循环队列 班 级 学 号 姓 名 评语 成绩 指导教师 批阅时间 年 月 日 数据结构 实验报告 - 1 - 线性数据结构算法实现与应用报告要求 ...
  • 循环队列的顺序存储结构Java

    千次阅读 2019-12-19 16:33:54
    循环队列的顺序存储结构 在上次,我们讲到的是,队列的顺序存储结构也是由ArrayList实现的,从此就可以看出,在入队时候的时间复杂度为O(1),但是在出队时候的时间复杂度为O(n),这是因为,每次在出队后要将数组后面...
  • 第三章 循环队列及线性结构综合

    千次阅读 2018-10-11 18:01:32
    1-1 所谓“循环队列”是指用单向循环链表或者循环数组表示的队列。 (1分) ...因此,循环队列是一个抽象的数据结构,而单向循环链表或循环数组是具体的实现方式,不是数据结构本身。   1-2 在用...
  • 数据结构循环队列的基本操作,分享一下,欢迎大家批评指正!
  • 循环队列的顺序存储结构 功能代码包含: 1)循环队列的顺序存储结构的数据结构定义 2)初始化循环队列 3)往循环队列中插入元素--入队 4)删除循环队列中的元素--出队 5)求循环队列的实际长度 注意:代码不进行...
  • 数据结构循环队列.cpp

    2021-03-03 15:42:22
    数据结构循环队列.cpp
  • 本文讲的是循环队列,首先我们必须明白下面几个问题 循环队列的基础知识 1.循环队列需要几个参数来确定 循环队列需要2个参数,front和rear 2.循环队列各个参数的含义 (1)队列初始化时,front和rear值都为零;...
  • 循环队列的顺序储存结构 文章目录循环队列的顺序储存结构队列的基本定义队列的基本操作初始化队列求队列长度入队列操作出队列函数打印该队列项目整体源代码: 队列的基本定义 队列是只允许在一端进行插入操作,而在...
  • 线性结构 循环队列

    千次阅读 2013-07-11 16:02:30
    一、循环队列与普通队列 1. 空判断条件相同:q->head == q->tail; 2. 满判断条件不同  1)循环队列:q->head == (q->tail + 1)%MAXSIZE;  2)普通队列:q->tail == MAXSIZE; 3. head与tail取值方式不同  1...
  • 数据结构循环队列的代码。。。。。。。。。。。。。。。
  • 栈与队列的数据类型描述及特点; 栈的顺序和链式存储存表示与基本算法的实现; 队列的链式存储表示与基本操作算法实现;栈与队列在实际问题中的应用和基本编程技巧;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 234,303
精华内容 93,721
关键字:

循环队列属于什么结构