C# 数据结构基础-实现循环队列

队列
    队列的概念是先进先出，这个应该不用多说了。看下面那个从网上找的现成图片。

循环队列
    循环队列在逻辑上将队列中的数据摆成环形，如下图：

下面直接上代码。

队列
    队列的概念是先进先出，这个应该不用多说了。看下面那个从网上找的现成图片。

循环队列
    循环队列在逻辑上将队列中的数据摆成环形，如下图：


下面直接上代码。

[csharp] view plain copy 在CODE上查看代码片派生到我的代码片
/// <summary>  
    /// 循环队列  
    /// 2015年1月4日  
    /// </summary>  
    /// <typeparam name="T"></typeparam>  
    public class MyCircleQueue<T>  
    {  
        /// <summary>  
        /// 队列数组  
        /// </summary>  
        private T[] _queue;  
        /// <summary>  
        /// 队首索引  
        /// </summary>  
        private int _front;  
        /// <summary>  
        /// 队尾索引  
        /// </summary>  
        private int _rear;  
          
        /// <summary>  
        /// 队列的内存大小，但实际可用大小为_capacity-1  
        /// </summary>  
        private int _capacity;  
  
        public MyCircleQueue(int queueSize)  
        {  
            if (queueSize < 1)  
                throw new IndexOutOfRangeException("传入的队列长度不能小于1。");  
  
            //设置队列容量  
            _capacity = queueSize;  
              
            //创建队列数组  
            _queue = new T[queueSize];  
  
            //初始化队首和队尾索引  
            _front = _rear = 0;  
        }  
  
        /// <summary>  
        /// 添加一个元素  
        /// </summary>  
        /// <param name="item"></param>  
        public void Push(T item)  
        {  
            //队列已满  
            if (GetNextRearIndex() == _front)  
            {  
                //扩大数组  
                T[] newQueue = new T[2 * _capacity];  
                  
                if (newQueue == null)  
                    throw new ArgumentOutOfRangeException("数据容量过大，超出系统内存大小。");  
                //队列索引尚未回绕  
                if (_front == 0)  
                {  
                    //将旧队列数组数据转移到新队列数组中  
                    Array.Copy(_queue, newQueue, _capacity);  
                }  
                else  
                {  
                    //如果队列回绕，刚需拷贝再次，  
                    //第一次将队首至旧队列数组最大长度的数据拷贝到新队列数组中  
                    Array.Copy(_queue, _front, newQueue, _front, _capacity - _rear - 1);  
                    //第二次将旧队列数组起始位置至队尾的数据拷贝到新队列数组中  
                    Array.Copy(_queue, 0, newQueue, _capacity, _rear + 1);  
                    //将队尾索引改为新队列数组的索引  
                    _rear = _capacity + 1;  
                }  
  
                _queue = newQueue;  
                _capacity *= 2;  
            }  
  
            //累加队尾索引，并添加当前项  
            _rear = GetNextRearIndex();  
            _queue[_rear] = item;  
        }  
  
        /// <summary>  
        /// 获取队首元素  
        /// </summary>  
        /// <returns></returns>  
        public T FrontItem()  
        {  
            if (IsEmpty())  
                throw new ArgumentOutOfRangeException("队列为空。");  
              
            return _queue[GetNextFrontIndex()];  
        }  
  
        /// <summary>  
        /// 获取队尾元素  
        /// </summary>  
        /// <returns></returns>  
        public T RearItem()  
        {  
            if (IsEmpty())  
                throw new ArgumentOutOfRangeException("队列为空。");  
  
            return _queue[_rear];  
        }  
  
        /// <summary>  
        /// 弹出一个元素  
        /// </summary>  
        /// <returns></returns>  
        public T Pop()  
        {  
            if (IsEmpty())  
                throw new ArgumentOutOfRangeException("队列为空。");  
  
            _front = GetNextFrontIndex();  
            return _queue[_front];  
        }  
  
        /// <summary>  
        /// 队列是否为空  
        /// </summary>  
        /// <returns></returns>  
        public bool IsEmpty()  
        {  
            return _front == _rear;  
        }  
        /// <summary>  
        /// 获取下一个索引  
        /// </summary>  
        /// <returns></returns>  
        private int GetNextRearIndex()  
        {  
            if (_rear + 1 == _capacity)  
            {  
                return 0;  
            }  
            return _rear + 1;  
        }  
  
        /// <summary>  
        /// 获取下一个索引  
        /// </summary>  
        /// <returns></returns>  
        private int GetNextFrontIndex()  
        {  
            if (_front + 1 == _capacity)  
            {  
                return 0;  
            }  
            return _front + 1;  
        }  
    }  

　　

转自：http://blog.csdn.net/liguo9860/article/details/42395009