引言:

队列就和我们平常排队买肾6一样，排队第一个肯定先能买到，也具有“先进先出”即所谓的FIFO,其实质用一维数组来存放顺序队列中的数据元素。插入操作限定在表的尾部而其它操作限定在表的头部进行的。队头位置设在数组下标为0的端，用front表示；队尾位置设在数组的另一端，用rear表示。front和rear随着插入和删除而变化。当队列为空时，front=rear=-1。但会隐藏一个隐患——假溢出（当队尾指针last=MaxSize - 1时，队列的前端可能还有许多，由于此前进行了删除操作而产生的空的位置。这样的情况，我们称为假溢出现象。）为了解决假溢出的问题，将顺序队列看成是首尾相接的循环结构，即所谓的循环队列，判断队空的条件是：rear==front，判断队满的条件是：(rear + 1) % maxsize==front。求循环队列中数据元素的个数可由(rear-front+maxsize)%maxsize公式求得。

定义接口：

 //定义队列的接口，对列的操作是按照先进先出(First In First Out)或后进后出( Last In Last Out)的原则进行的，因此，队列又称为FIFO表或LILO表
    public interface IQueue<T>
    {
        int GetLength();//获取队列的长度
        bool IsEmpty();//是否为空队列
        void Clear();//清空
        void In(T item);//入队
        T Out();//出队
        T GetFrontItem();//取列头元素
    }

循环顺序队列的实体类实现：

几个关键的操作：

1. 访问队列元素：data[front+1]
2. 满队：(rear + 1) % maxsize==front
3. 空对：rear==front
4. 遍历:front++

public class CircularQueue<T> : IQueue<T>
    {
        #region 成员变量
        private int maxsize; //循环顺序队列的容量
        private T[] data; //数组，用于存储循环顺序队列中的数据元素
        private int front; //指示循环顺序队列的队头
        private int rear; //指示循环顺序队列的队尾

        #endregion
        #region 索引器
        public T this[int index]
        {
            get
            {
                return data[index];
            }
            set
            {
                data[index] = value;
            }
        }
        #endregion
        #region 成员属性
        //容量属性
        public int Maxsize
        {
            get
            {
                return maxsize;
            }
            set
            {
                maxsize = value;
            }
        }
        //队头属性
        public int Front
        {
            get
            {
                return front;
            }
            set
            {
                front = value;
            }
        }
        //队尾属性
        public int Rear
        {
            get
            {
                return rear;
            }
            set
            {
                rear = value;
            }
        }
        #endregion
        #region 构造方法
        public CircularQueue(int size)
        {
        data = new T[size];
        maxsize = size;
        front = rear = -1;
        }
        #endregion
        #region 成员方法
        //求循环顺序队列的长度
        public int GetLength()
        {
            return (rear - front + maxsize) % maxsize;
        }
        //清空循环顺序队列：rear和front均等于-1。
        public void Clear()
        {
            front = rear = -1;
        }
        //判断循环顺序队列是否为空
        public bool IsEmpty()
        {
            if (front == rear)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //判断循环顺序队列是否为满:(rear + 1) % maxsize==front
        public bool IsFull()
        {
            if ((rear + 1) % maxsize==front)
            {
            return true;
            }
            else
            {
                return false;
            }
        }
        //入队：先使循环顺序队列的rear加1，front不变，然后在rear指示的位置添加一个新元素。
        public void In(T item)
        {
            if (IsFull())
            {
                Console.WriteLine("Queue is full");
                return;
            }
            data[++rear] = item;
        }
        //出队：使队头指示器front加1，rear不变
        public T Out()
        {
            T tmp = default(T);
            //判断循环顺序队列是否为空
            if (IsEmpty())
            {
                Console.WriteLine("Queue is empty");
                return tmp;
            }
            tmp = data[++front];
            return tmp;
        }
        //获取队头数据元素
        public T GetFrontItem()
        {
            if (IsEmpty())
            {
                Console.WriteLine("Queue is empty!");
                return default(T);
            }
            return data[front + 1];
        }
        //遍历：
        public void showQueue()
        {
            while (front!=rear)
            {
                Console.Write(data[front+1]+ "\t");
                front++;
            }
        }
        #endregion
    }

循环队列的简单测试：

“`
CircularQueue cirQueue = new
CircularQueue(5);
cirQueue.In(2);
cirQueue.In(5);
cirQueue.In(8);
Console.WriteLine(“遍历顺序循环队列:” + “\n”);
cirQueue.showQueue();