数据结构的C实现_循环队列

队列的操作特点是“先进先出”。前者主要是头指针、尾指针的使用，后者主要是理解循环队列提出的原因及其特点。两者都要掌握队列空与满的判定条件以及出队列、入队列操作的实现。

//循环队列

#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 10//循环队列的最大元素数量
typedef char elemType;//元素类型

typedef struct _queue
{
elemType elems[MAXSIZE];
elemType front,rear;  //front指向当前的头部的元素，rear指向下一个将要插入元素的位置
}Queue;

//初始化队列
int InitQueue(Queue *q)
{
q->front=q->rear=0;
return OK;
}

//遍历队列
int ShowQueue(Queue *q)
{
int i;
if(q->front==q->rear)
{
printf("队列为空\n");
return ERROR;
}
printf("队列中的元素为:\n");
for(i=((q->front)%MAXSIZE); i<q->rear; i=((i+1)%MAXSIZE))   //重点
printf(" %c",q->elems[i]);
printf("\n");
printf("队首元素为%c\n",q->elems[q->front]);
printf("队尾元素为%c\n",q->elems[q->rear-1]);
return OK;
}

//向队尾插入元素e
int InQueue(Queue *q,elemType e)
{
if((q->rear+1)%MAXSIZE==q->front)
{
printf("空间不足\n");
return(OVERFLOW);
}
q->elems[q->rear]=e;
q->rear=(q->rear+1)%MAXSIZE;
return OK;
}

//从队首删除元素
int OutQueue(Queue *q)
{
if(q->front==q->rear)
{
printf("队列为空\n");
return ERROR;
}
printf("被删除的队首元素为%c\n",q->elems[q->front]);
q->front=(q->front+1)%MAXSIZE;
return OK;
}

//队列中的元素个数
int Length(Queue *q)
{
return (q->rear-q->front+MAXSIZE)%MAXSIZE;
}

main()
{
Queue q;
InitQueue(&q);
ShowQueue(&q);

printf("对尾插入元素...\n");
InQueue(&q,'a');
InQueue(&q,'b');
InQueue(&q,'c');
InQueue(&q,'d');
ShowQueue(&q);
printf("队列中的元素个数为%d\n",Length(&q));

printf("队首删除元素..\n");
OutQueue(&q);
ShowQueue(&q);

}  

------------------------------------------------------------------------------------------

--------------------------------C++----------------------------------------------------

/*
 *循环队列
 */
#include <iostream>
using std::cout;
using std::endl;

template <typename T>
class SqQueue{
public:
    SqQueue(int init=50);
    bool SqQueueEmpty() const;//判断循环队列是否为空
    void SqQueueTraverse() const;//遍历循环队列
    int SqQueueLength() const;//返回队列中元素个数
        
    bool EnSqQueue(T e);
    bool DelSqQueue();
    
private:
    int size; //允许的最大存储空间以元素为单位
    int front;//队头指针
    int rear;//队尾指针
    T *base; //存储空间基址
};

template <typename T>
SqQueue<T>::SqQueue(int init){   //构造函数
    size = init; //初始大小
    base = new T[size];
    if(!base)exit(1);//存储分配失败
    front = rear = 0;   //空栈中元素个数为0
}
// 返回队列Q中元素个数，即队列的长度
template <typename T>
int SqQueue<T>::SqQueueLength() const {
    return ((rear-front+size) % size);
}

template <typename T>
void SqQueue<T>::SqQueueTraverse() const {
    int length = (rear-front+size) % size;
    cout << "从队尾到队头: ";
    while(length--){
        cout << base[front+length] << " ";
    }
    cout << endl;
}

//若当前队列不满，这在当前队列的尾元素之后，
//插入元素 e 为新的队列尾元素,并返回TRUE,否则返回FALSE
template <typename T>
bool SqQueue<T>::EnSqQueue(T e){
    if((rear+1)%size  == front){//队列满
        return false;
    }
    base[rear] = e;
    rear = (rear+1) % size;
    return true;
}
template <typename T>
bool SqQueue<T>::DelSqQueue(){
    if(front == rear){//队列空
        return false;
    }
    front = (front+1) % size;
    return true;
}

******************************************************************************************

main.cc
******************************************************************************************
#include "SqQueue.h"

int main()
{
    SqQueue<int> *sq = new SqQueue<int>;
    sq->EnSqQueue(1);
    sq->EnSqQueue(2);
    sq->EnSqQueue(3);
    sq->EnSqQueue(4);
    sq->EnSqQueue(5);
    sq->EnSqQueue(6);
    
    cout << "队列长度: " << sq->SqQueueLength() << endl;
    sq->SqQueueTraverse();
    
    cout << "删除对头后：" << endl;
    sq->DelSqQueue();
    cout << "队列长度: " << sq->SqQueueLength() << endl;
    sq->SqQueueTraverse();
    return 0;
}

******************************************************************************************