循环队列

循环队列

@

目录

• 循环队列
  • 1，循环队列
  • 2，C语言实现循环队列
  • 3，OOP实现循环队列

1，循环队列

队列的操作特点是“先进先出”。为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。

2，C语言实现循环队列

#include<stdio.h>
#include<assert.h>
#define SIZE 8
typedef struct Queue
{
	int elem[SIZE];//数组
	int front;//头
	int rear;//尾
}Queue,*QueueS;

void InitQueueS(QueueS queue)           //初始化
{
    asesrt(queue!=NULL);
    queue->front=0;
    queue->rear=0;
}
bool Push(QueueS queue,int val)         //入队
{
    assert(queue!=NULL);
    if(IsFull(queue))
    {
     return false;
    }
    queue->elem[queu->rear]=val;
    queue->rear=(queue->rear+1)%SIZE;
    return true;
}
bool Pop(QueueS queue,int *rtv)       //出队
{
    assert(queue!=NULL)
    if(IsEmpty(queue))
    {
        return false;
    }
    if(rtv!=NULL)
    {
        *rtv=queue->elem[queue->front];
    }
    queue->front=(queue->front+1)%SIZE;
    return true;
}
void Show(QueueS queue)
{
    for(int i=queue->front;i!=queue->rear;i=(i+1)%SIZE)
    {
        printf("%d ",queue->elem[i]);
    }
    printf("
");
}
int GetLength(QueueS queue)      //获取长度
{
    return (queue->rear-queu->front+SIZE)%SIZE;
}
bool IsFull(QueueS queue)        //判满
{
    return (queue->rear+1)%SIZE==queue->front;
}
bool IsEmpty(QueueS queue)         //判空
{
    return queue->front==queue->rear;
}
void Clear(QueueS queue)
{
    queue->front=queue->rear;
}
void Destroy(QueueS queue)
{
    Clear(queue);
}

3，OOP实现循环队列

#include<iostream>
using namespace std;
class CQueue
{
public:
    CQueue(int size=10)
    {
        mfront=mrear=0;
        msize=size;
        mqueue=new int[msize];
    }
   /* CQueue(int size=10):mfront(0),mrear(0),msize(size)
    {
        mqueue=new int [msize];
    }
    */
    ~CQueue()
    {
        delete[]mqueue;
        mqueue=NULL;
    }
    CQueue(const CQueue&src)
    {
        mfront=src.mfront;
        mrear=src.mrear;
       mszie=src.msize;
        mqueue=new int [src.msize];
        for(int i=mfront;i!=mrear;i=(i+1)%msize)
        {
            mqueue[i]=src.mqueue[i];
        }
    }
    void operator=(const CQueue&src)
    {
        if(this==&src)
        {
            return ;
        }
        delete[]mqueue;
        mqueue=NULL;
        mfront=src.mfront;
        mrear=src.mrear;
        mszie=src.msize;
        mqueue=new int [src.msize];
        for(int i=mfront;i!=mrear;i=(i+1)%msize)
        {
            mqueue[i]=src.mqueue[i];
        }
    }
    void push(int val)
    {
        if(full())
        {
            return;
        }
        mqueue[mrear]=val;
        mrear=(mrear+1)%msize;
    }
    void pop()
    {
        if(empty())
        {
            return;
        }
        mfront=(mfront+1)%msize;
    }
    int front()
    {
        return mqueue[mfront];
    }
    int back()
    {
        if(mrear==0)
        {
            return mqueue[msize-1];
        }
        else
        {
            return mqueue[mrear-1];
        }
    }
    bool full()
    {
        return (mrear+1)%msize==mfront;
    }
    bool empty()
    {
        treturn mrear==mfront;
    }
    void show()
    {
        for(int i=mfront;i!=mrear;i=(i+1)%msize)
        {
            cout<<mqueue[i]<<" ";
        }
    }
 private:
    int*mqueue;
    int mfront;
    int mrear;
    int msize;
    void resize()
    {
        int *mtmp=new int[msize*2];
        for(int i=mfront,j=0;i!=mrear;i=（i+1）%msize,j++)
        {
            mtmp[j]=mqueue[i]
        }
        delete[]mqueue;
        mqueue=mtmp;
        mfront=0;
        mrear=msize-1;
        msize*=2;
    }
};