数据结构——队列

原文：http://www.cnblogs.com/skywang12345/p/3562279.html

队列的介绍

队列（Queue），是一种线性存储结构。它有以下几个特点：
(01) 队列中数据是按照"先进先出（FIFO, First-In-First-Out）"方式进出队列的。
(02) 队列只允许在"队首"进行删除操作，而在"队尾"进行插入操作。
队列通常包括的两种操作：入队列 和 出队列。

 

1. 队列的示意图

队列中有10，20，30共3个数据。

 

2. 出队列

出队列前：队首是10，队尾是30。
出队列后：出队列(队首)之后。队首是20，队尾是30。

 

3. 入队列

入队列前：队首是20，队尾是30。
入队列后：40入队列(队尾)之后。队首是20，队尾是40。

 

队列的.NET实现

1. 实现一：数组实现的队列，能存储任意类型的数据。
2. 实现二：Java的 Collection集合 中自带的"队列"(LinkedList)的示例。

 

1.实现一：数组实现的队列，能存储任意类型的数据

 

    /// <summary>
    /// 数组实现“队列”，只能存储int数据。
    /// </summary>
    public class ArrayQueue
    {

        private int[] mArray;
        private int mCount;

        public ArrayQueue(int sz)
        {
            mArray = new int[sz];
            mCount = 0;
        }

        // 将val添加到队列的末尾
        public void add(int val)
        {
            mArray[mCount++] = val;
        }

        // 返回“队列开头元素”
        public int front()
        {
            return mArray[0];
        }

        // 返回“队首值”，并删除“队首元素”
        public int pop()
        {
            int ret = mArray[0];
            mCount--;
            for (int i = 1; i <= mCount; i++)
                mArray[i - 1] = mArray[i];
            return ret;
        }

        // 返回“队列”的大小
        public int size()
        {
            return mCount;
        }

        // 返回“队列”是否为空
        public bool isEmpty()
        {
            return size() == 0;
        }

    }

 

 

 

运行结果：

tmp=10
tmp=20
isEmpty()=false
size()=3
size()=20
size()=30
size()=40

结果说明：ArrayQueue是通过数组实现的队列，而且ArrayQueue中使用到了泛型，因此它支持任意类型的数据。

 

2. 实现二：Collection集合 中自带的"队列"(LinkedList)的示例

 

    /// <summary>
    ///  用“栈”实现队列
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class StackList<T>
    {

        // 向队列添加数据时：(01) 将“已有的全部数据”都移到mIn中。 (02) 将“新添加的数据”添加到mIn中。
        private Stack<T> mIn = null;
        // 从队列获取元素时：(01) 将“已有的全部数据”都移到mOut中。(02) 返回并删除mOut栈顶元素。
        private Stack<T> mOut = null;
        // 统计计数
        private int mCount = 0;

        public StackList()
        {
            mIn = new Stack<T>();
            mOut = new Stack<T>();
            mCount = 0;
        }

        public void add(T t)
        {
            // 将“已有的全部数据”都移到mIn中
            while (mOut.Count > 0)
                mIn.Push(mOut.Pop());

            // 将“新添加的数据”添加到mIn中
            mIn.Push(t);
            // 统计数+1
            mCount++;
        }

        public T get()
        {
            // 将“已有的全部数据”都移到mOut中
            while (mIn.Count > 0)
                mOut.Push(mIn.Pop());
            // 统计数-1
            mCount--;

            // 返回并删除mOut栈顶元素
            return mOut.Pop();
        }

        public int size()
        {
            return mCount;
        }
        public bool isEmpty()
        {
            return mCount == 0;
        }


    }

 

 

 

运行结果：

tmp=10
tmp=20
isEmpty()=false
size()=3
tmp=20
tmp=30
tmp=40

 

转载于:https://www.cnblogs.com/luanxm/p/10392177.html