循环队列数据结构

顺序
循环队列初始化：front=rear=0；
入队操作：rear=(rear+1)%Maxsize;
出队操作：front=(front+1)%Maxsize;
判断是否为空队列：front==rear；
判断队列是否已满：front=(rear+1)%Maxsize；

#include<stdio.h>
#include <malloc.h>
#define Maxsize 10
typedef struct QNode* PtrNode;
struct QNode//单个结点
{
	int* data;
	int front, rear;
	int maxsize;
};
typedef PtrNode queue;

queue create(int maxsize)
{
	queue q = (queue)malloc(sizeof(QNode));
	q->data = (int*)malloc(maxsize * (sizeof(QNode)));
	q->front = q->rear = 0;
	q->maxsize = Maxsize;
	return q;
}

bool is_full(queue q)
{
	return(q->rear + 1 % q->maxsize == q->front);
}

bool addq(queue q, int x)
{
	if (is_full(q))
	{
		return false;
	}
	else
	{
		q->rear = (q->rear + 1) % q->maxsize;//
		q->data[q->rear] = x;
		printf("%d 入队", q->data[q->rear]);
		return true;
	}
}

bool is_empty(queue q)
{
	return(q->front == q->rear);
}

void Delete(queue q)
{
	if (is_empty(q))
	{
		return;
	}
	else
	{
		q->front = (q->front + 1) % q->maxsize;
		//printf_s("%d",q->data[q->front]);
	}
}

int main()
{
	queue q;
	q = create(Maxsize);
	addq(q, 1);
	addq(q, 2);
	addq(q, 3);
	Delete(q);

	int tail = q->front;
	while (tail != q->rear)
	{
		tail = (tail + 1) % Maxsize;
		printf_s(" %d", q->data[tail]);
	}
}

链式

#include <iostream>
#include<stdlib.h>
using namespace std;
 
 
typedef struct QNode   //定义一个连队列的结点
{
    int data;
    struct QNode *next;
}QNode;
typedef struct         //定义链队列的数据结构
{
    QNode *front;
    QNode *rear;
}LinkQueue;
 
// 构造一个空队列q
LinkQueue *InitQueue(LinkQueue *q)
{
	QNode *tmp = (QNode*)malloc(sizeof(QNode));
    q->front = tmp;
	q->rear = tmp;
    q->front->next = NULL;
    return q;
}
// 元素入队
LinkQueue *EnQueue(LinkQueue *q, int e)
{
    QNode *p = (QNode*)malloc(sizeof(QNode));//为插入节点分配空间
    if(!p)
    {//分配空间失败
        cout<<"插入节点内存分配失败！"<<endl;
    }
    else
    {   //建节点
        p->data = e; //为插入节点数据域赋值
        p->next = NULL;//为插入节点指针域赋值
        //实现插入
        q->rear->next = p;//插入到队尾
        q->rear = p;//队尾指针重新指向新任队尾
    }
    return q;
}
//元素出队
LinkQueue *DeQueue(LinkQueue *q)
{
    QNode *p;
    if(q->front == q->rear)
    {
        cout<<"链队列已空，不可再执行删除操作！"<<endl;
    }
    else
    {
        p = q->front->next;//将欲删除的队头结点暂存给p
        int e = p->data;//把队头数据赋给e
        cout <<"delete: " << e <<endl;
        q->front->next = p->next;//删除,将原队头结点的后继p->next赋值给头结点后继
        if(q->rear == p)    //此时链队列只存在一个元素结点
        {
			//若队头就是队尾，则删除后将rear指向头结点
            cout<<"链队列数据全部删除完毕！"<<endl;
            q->rear = q->front;
        }
        free(p);
    }
    return q;
}
//返回队头元素
void GetQHead(LinkQueue *q)
{
    QNode *p;
    if(q->front == q->rear)
    {
        cout<<"链队列为空，无法返回队头数据"<<endl;
    }
    else
    {
        p = q->front->next;//队头
        cout<< "队头元素：" << p->data <<endl;
    }
}
//求队列长度
void QueueLength(LinkQueue *q)
{
    int length = 0;
    QNode *p;
    p = q->front->next;//队头
    while(p)
    {
        length++;
        p = p->next;
    }
    cout<<"队列长度："<< length << endl;
}
//打印。带头结点，真正存储元素的位置从头结点下一位置（队头）开始！！！
void PrintQueue(LinkQueue *q)
{
    QNode *p;//队头
    p = q->front->next;//头结点的下一节点，即为队头！！！
    while(p)
    {//从队头开始，依次往后遍历
        cout<< p->data <<" ";
        p = p->next;
    }
    cout << endl;
}
int main()
{
    LinkQueue q ;
	InitQueue(&q);
 
    EnQueue(&q, 1);
    PrintQueue(&q);
    EnQueue(&q, 2);
    PrintQueue(&q);
    EnQueue(&q, 3);
    PrintQueue(&q);
    EnQueue(&q, 4);
    PrintQueue(&q);
 
    GetQHead(&q);
 
    QueueLength(&q);
    cout<<"***************"<<endl;
    DeQueue(&q);
    PrintQueue(&q);
    GetQHead(&q);
 
    DeQueue(&q);
    PrintQueue(&q);
    GetQHead(&q);
 
    DeQueue(&q);
    PrintQueue(&q);
 
    DeQueue(&q);
    PrintQueue(&q);
 
    QueueLength(&q);
 
    cout<<"***************"<<endl;
    DeQueue(&q);
    cout<<"***************"<<endl;
 
    return 0;
}