可自动增长队列长度的泛型循环队列

最近不忙，随便写写！

队列代码：

 /// <summary>
    /// 一个可以自动增长长度的队列，并且可以重复循环队列
    /// </summary>
    /// <typeparam name="T">自定义的泛型</typeparam>
    class Queue  <T>
    {   //队列出队index     
        int front;
        //队列入队Index
        int back;
        //队列中元素数量
        int size;
        //队列的初始长度设置为3
        T[] data=new T [3] ;
        //获取队列中的元素数量
        public int QueueSize
        {
            get { return size; }
        }
        /// <summary>
        /// 元素出队
        /// </summary>
        /// <returns></returns>
        public T DeQueue()
        {
            T t =default(T );
            if (size != 0)
            {
                SetFrontToZero();               
                t = data[front];
                data[front] = default(T);
                front++;
                size--;
             

            }
            return t;
        }
        /// <summary>
        /// 元素入队
        /// </summary>
        /// <param name="t"></param>
        public void EnQueue(T t)
        {

            AddQueueSize();
            SetBackToZero();
           
            data[back] = t;
            back++;      
            size++;

        }
        //队列自增长
        private  void AddQueueSize()
        {
            if (size >= data.Length)
            {
                back = size;
                T[] newData = new T[data.Length * 2];

                for (int i = 0; i < data.Length; i++)
                {
                    newData[i] = DeQueue();

                }
                data = newData;

                size = back;
                front = 0;
            }
        }
         /// <summary>
         /// 设置出队index
         /// </summary>
        private void SetBackToZero()
        {
            if (back == data.Length&&size <data .Length )
            {
                back = 0;
            }
        }
        /// <summary>
        /// 设这出队Index
        /// </summary>
        private void SetFrontToZero()
        {
            if (front  == data.Length && size !=0)
            {
                front = 0;
            }
        }

    }

 

测试用到的泛型数据：

/// <summary>
    /// 个人成绩结构体
    /// </summary>
    class SocreMode : IComparable,ICloneable 
    {
        public string mFileName = "";
        public string mMail = "";
        public string mName = "";
        public int mSocre;
        public string FileName
        {
            get
            {
                return mFileName;
            }
            set
            {
                mFileName = value;
            }
        }
        public string Mail
        {
            get
            {
                return mMail;
            }
            set { mMail = value; }

        }
        public string Name
        {
            get { return mName; }
            set { mName = value; }

        }
        public int  Socre
        {
            get { return mSocre; }
            set { mSocre = value; }
        }
        /// <summary>
        /// 实现IComparable接口
        /// </summary>
        /// <param name="obj">SocreMode对象</param>
        /// <returns></returns>
        int IComparable.CompareTo(object obj)
        {
            SocreMode temp = (SocreMode)obj;
            if (temp.mName == mName)
            {
                return this.mMail.CompareTo(temp.mMail);

            }
            else
            {
                return this.mName.CompareTo(temp.Name);
            }
        }
        /// <summary>
        ///  重载ToString 方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format(mMail.PadRight(30) + "\t" + mName.PadRight(15 - (System.Text.Encoding.Default.GetByteCount(mName) - mName.Length)) + "\t" + mSocre.ToString());
        }
        public object Clone()
        {
            SocreMode temp = new SocreMode();
            temp.mSocre = this.mSocre;
            return temp;

        }
    }