数据结构 -- 链式队列

队列：先进先出的数据结构

C#版本：

namespace Queue
{
    interface IQueue<T>
    {
        /// <summary>入队操作</summary>
        bool EnQueue(T _data);
        /// <summary>出队操作</summary>
        bool DeQueue(ref T _data);
        /// <summary>取队头元素</summary>
        bool GetFront(ref T _data);
        /// <summary>获取队列长度</summary>
        int QueueLength();
        /// <summary>是否为空</summary>
        bool IsEmpty();
        /// <summary>清空队列</summary>
        void Clear();
        /// <summary>是否满</summary>
        bool IsFull();
    }

    class QueueNode<T>
    {
        #region 成员属性
        private T data; //数据
        private QueueNode<T> next;  //指针
        #endregion
        #region 公开属性
        public T Data
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }
        public QueueNode<T> Next;
        #endregion

        #region 构造函数
        public QueueNode()
        {
            Data = default(T);
            Next = null;
        }
        public QueueNode(T _data = default(T),QueueNode<T> _next = null)
        {
            Data = _data;
            Next = _next;
        }
        #endregion
    }


    /// <summary>链式队列 </summary>
    class LinkQueue<T> : IQueue<T>
    {
        #region 成员属性
        private QueueNode<T> front; //队列头指示器
        private QueueNode<T> rear;  //队列尾指示器
        private int nodeNum;       //队列节点个数
        #endregion

        #region 访问函数   
        public LinkQueue()
        {
            front = null;
            rear = null;
            nodeNum = 0;
        }

        /// <summary>入队操作，数据保存在_data中</summary>
        public bool EnQueue(T _data)
        {
            if (IsFull())
                return false;

            QueueNode<T> q = new QueueNode<T>(_data);
            if (IsEmpty())
            {
                front = q;
                rear = q;
            }
            else
            {
                rear.Next = q;
                rear = q;
            }
            ++nodeNum;

            return true;
        }

        /// <summary>出队操作，数据保存在_data中</summary>
        public bool DeQueue(ref T _data)
        {
            if (IsEmpty())
                return false;

            _data = front.Data;
            front = front.Next;

            if (front == null)
                rear = null;

            --nodeNum;
            return true;   
        }

        /// <summary>获取队头元素值操作，数据保存在_data中</summary>
        public bool GetFront(ref T _data)
        {
            if (IsEmpty())
                return false;
            _data = front.Data;
            return true;
        }

        /// <summary>返回队列是否为空</summary>
        public bool IsEmpty()
        {
            if (front == rear && 0 == nodeNum)
                return true;
            return false;
        }

        /// <summary>返回队列是否满</summary>
        public bool IsFull()
        {
            return false;
        }

        /// <summary>返回队列长度</summary>
        public int QueueLength()
        {
            return nodeNum;
        }

        /// <summary>清空队列</summary>
        public void Clear()
        {
            front = rear = null;
            nodeNum = 0;
        }

        #endregion
    }
}