第四篇 栈与队列（二）

一、队列的定义

　　队列（queue）是只允许在一段进行插入操作，而在另一端进行删除操作的线性表，队列是一种先进先出（First in First Out）的线性表，简称为FIFO。而堆栈为先进后出的线性表（FILO）。允许插入的一端称为队尾，允许删除的一端称为队头。

　　如图所示：

二、队列的抽象数据结构

　　因为队列本身是线性表，因此具有线性表的所有特性。而作为先进先出的线性表，也有其自身的一些特性。

　　如图所示：

三、循环队列

　　在队列的顺序存储结构中，对队列进行插入操作，是在其队尾插入一个元素，可以一直添加到队列已满为止，算法复杂度为O(1)，而当执行取出操作时，在队列的头部取出一个元素，同时其后面的元素依此向前移动一位。从而导致其算法复杂度为O(n)。其实这类似与我们日常排队买票的情景，当前面的人买到票以后，离开了，后面的所有等待购票的人依此向前前进一步。

　　为了解决上面插入操作时后面的依此向前移动，我们提出了循环队列。

　　循环队列：我们把头尾相接的顺序存储结构的队列称为循环队列。

四、循环队列的算法实现

采用空闲一个位置的方式，即N个元素空间的循环队列最多只能存放N-1个有效元素。这也是大多数教材的做法。
1) 循环队列初始化：front=rear=0；
2）入队操作：rear=(rear+1)%size;
3）出队操作：front=(front+1)%size;
4）判断是否为空队列：front==rear；
5）判断队列是否已满：front=(rear+1)%size；
6）遍历队列各元素。

　　C#代码如下

 /// <summary>
    /// 循环队列的算法实现
    /// </summary>

    /*
     *算法描述
     * 采用空闲一个位置的方式，即N个元素空间的循环队列最多只能存放N-1个有效元素。这也是大多数教材的做法。
        1) 循环队列初始化：front=rear=0；
        2）入队操作：rear=(rear+1)%size;
        3）出队操作：front=(front+1)%size;
        4）判断是否为空队列：front==rear；
        5）判断队列是否已满：front=(rear+1)%size；
        6）遍历队列各元素。
     *
     */

    /*
     *参考资料
     *http://www.cnblogs.com/zhaoyl/archive/2012/09/20/2695136.html
     *http://blog.csdn.net/huangkq1989/article/details/5719529
     * 大话数据结构
     */

    public class CirculeQueue
    {
        /// <summary>
        /// 队列的头指针
        /// </summary>
        public int Front;

        /// <summary>
        /// 队列的尾指针
        /// </summary>
        public int Rear;

        /// <summary>
        /// 队列的数据
        /// </summary>
        public DataType[] Data;

        /// <summary>
        /// 队列的长度
        /// </summary>
        public int Length;

        /// <summary>
        /// 队列的最大值
        /// </summary>
        public int MaxSize;

        public CirculeQueue(int maxSize)
        {
            if (maxSize < 1)
                throw new ApplicationException("The queue size can not less than 1.");
            Data = new DataType[maxSize];
            MaxSize = maxSize;
        }

        /// <summary>
        /// 队列是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return Front == Rear;
        }

        /// <summary>
        /// 插入队列元素
        /// </summary>
        /// <param name="element">元素</param>
        public void Enqueue(DataType element)
        {
            //先判断队列是否已满
            if (Front == (Rear + 1) % MaxSize)
                throw new ApplicationException("The Queue is Full.");
            //在队尾插入元素，队尾指针向后移动一位
            Rear = (Rear + 1) % MaxSize;
            Data[Rear] = element;
            Length++;
        }

        /// <summary>
        /// 取出队头元素
        /// </summary>
        /// <returns></returns>
        public DataType Dequeue()
        {
            //先判断队列是否为空
            if (Front == Rear)
                throw new ApplicationException("The Queue is Empty.");
            //从队头取出元素
            Front = (Front + 1) % MaxSize;
            Length--;
            return Data[Front];
        }
    }

    /// <summary>
    /// 队列元素
    /// </summary>
    public class DataType
    {
        public object Data { get; set; }
    }

五、队列的链式存储结构

　　队列的链式存储结构，其实就是线性表的单链表，只不不过它只能尾进头出。称为链队列。

　如图

　　当队列为空时，front和rear都指向头节点。

　　链队列的结构：如下图所示

链队列的算法实现

C#代码如下：

  /// <summary>
    /// 链队列的算法实现
    /// </summary>

    /*
     * 算法描述
     * 链队列属于单链表，因此具有单链表的特性
     *  1) 循环队列初始化：front=rear=null；
        2）入队操作：申请存储空间，将队尾指针移动一位;
        3）出队操作：指向队头指针;
     *
     */

    /*
     * 参考资料
     * http://www.cnblogs.com/iwuyudong/archive/2010/12/20/2234111.html
     * http://blog.163.com/zhoumhan_0351/blog/static/39954227201001411343987/
     * http://www.cnblogs.com/navorse/articles/1889247.html
     * http://blog.chinaunix.net/uid-21768364-id-186080.html
     */
    public class LinkedQueue
    {
        /// <summary>
        /// 队列的头指针
        /// </summary>
        public Node FrontNode;

        /// <summary>
        /// 队列的尾指针
        /// </summary>
        public Node RearNode;

        /// <summary>
        /// 队列的数据
        /// </summary>
        public DataType[] Data;

        /// <summary>
        /// 队列的长度
        /// </summary>
        public int Length;

        public LinkedQueue()
        {

        }

        /// <summary>
        /// 队列是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return FrontNode == RearNode;
        }

        /// <summary>
        /// 插入队列元素
        /// </summary>
        /// <param name="element">元素</param>
        public void Enqueue(DataType element)
        {
            //创建新节点存放数据
            Node node = new Node();
            node.Data = element;
            node.NextNode = null;
            //将尾节点指向当前节点
            RearNode.NextNode = node;
            RearNode = node;
            Length++;
        }

        /// <summary>
        /// 取出队头元素
        /// </summary>
        /// <returns></returns>
        public DataType Dequeue()
        {
            //先判断队列是否为空
            if (FrontNode == RearNode)
                throw new ApplicationException("The Queue is Empty.");
            //将要删除的头节点赋给tempNode节点
            Node tempNode = FrontNode.NextNode;
            //将头结点的值赋给数据项data
            DataType data = tempNode.Data;
            //将原队头给点后继p->next 赋值给头给点后继.
            FrontNode = tempNode.NextNode;
            if (RearNode == tempNode)
                RearNode = FrontNode;
            return data;
        }
    }

    public class Node
    {
        /// <summary>
        /// 数据存储单元
        /// </summary>
        public DataType Data { get; set; }

        /// <summary>
        /// 下一个节点
        /// </summary>
        public Node NextNode { get; set; }
    }