C#數組和鏈表實現隊列

  //基於數組的隊列實現
    public class MyArrayQueue<T>
    {
        private T[] items;
        private int size;
        private int head;
        private int tail;

        public MyArrayQueue(int capacity)
        {
            this.items = new T[capacity];
            this.size = 0;
            this.head = this.tail = 0;
        }

        /// <summary>
        /// 入隊
        /// </summary>
        /// <param name="item">入隊元素</param>
        public void EnQueue(T item)
        {
            if (Size == items.Length)
                // 擴大數組容量
                ResizeCapacity(items.Length * 2);
            items[tail] = item;
            tail++;
            size++;
        }
        /// <summary>v 
        /// 出隊
        /// </summary>
        /// <returns>出隊元素</returns>
        public T DeQueue()
        {
            if (size == 0) return default(T);
            T item = items[head];
            items[head] = default(T);
            head++;
            if (head > 0 && Size == items.Length / 4)
                ResizeCapacity(items.Length / 2);

            size--;
            return item;
        }

        /// <summary>
        /// 重置數組大小
        /// </summary>
        /// <param name="newCapacity">新的容量</param>
        public void ResizeCapacity(int newCapacity)
        {
            T[] newItems = new T[newCapacity];
            int index = 0;
            if (newCapacity > items.Length)
            {
                for (int i = 0; i < items.Length; i++)
                    newItems[index++] = items[i];
            }
            else
            {
                for (int i = 0; i < items.Length; i++)
                {
                    if (!items[i].Equals(default(T)))
                    {
                        newItems[index++] = items[i];
                    }
                }
                head = tail = 0;
            }
            items = newItems;
        }
        /// <summary>
        /// 棧是否為空
        /// </summary>
        /// <returns>true/false</returns>
        public bool IsEmpty()
        {
            return this.size == 0;
        }

        /// <summary>
        /// 棧中節點個數
        /// </summary>
        public int Size
        {
            get
            {
                return this.size;
            }
        }
    }

　　

public class Node<T>
    {
        public T Item { get; set; }
        public Node<T> Next { get; set; }

        public Node(T item)
        {
            this.Item = item;
        }

        public Node()
        { }
    }

    /// <summary>
    /// 基於鏈表的隊列實現
    /// </summary>
    /// <typeparam name="T">類型</typeparam>
    public class MyLinkQueue<T>
    {
        private Node<T> head;
        private Node<T> tail;
        private int size;

        public MyLinkQueue()
        {
            this.head = null;
            this.tail = null;
            this.size = 0;
        }

        /// <summary>
        /// 入隊操作
        /// </summary>
        /// <param name="node">節點元素</param>
        public void EnQueue(T item)
        {
            Node<T> oldLastNode = tail;
            tail = new Node<T>();
            tail.Item = item;

            if (IsEmpty())
            {
                head = tail;
            }
            else
            {
                oldLastNode.Next = tail;
            }

            size++;
        }

        /// <summary>
        /// 出隊操作
        /// </summary>
        /// <returns>出隊元素</returns>
        public T DeQueue()
        {
            T result = head.Item;
            head = head.Next;
            size--;

            if (IsEmpty())
            {
                tail = null;
            }
            return result;
        }

        /// <summary>
        /// 是否為空隊列
        /// </summary>
        /// <returns>true/false</returns>
        public bool IsEmpty()
        {
            return this.size == 0;
        }

        /// <summary>
        /// 隊列中節點個數
        /// </summary>
        public int Size
        {
            get
            {
                return this.size;
            }
        }
    }

　　

 class Program
    {
        static void Main(string[] args)
        {
            // 01.基於鏈表的隊列
            QueueWithLinkListTest();
            // 02.基於數組的隊列
            //QueueWithArrayTest();
        }
        #region Method01.基於鏈表的隊列的測試
        /// <summary>
        /// 基於鏈表的隊列的測試
        /// </summary>
        static void QueueWithLinkListTest()
        {
            MyLinkQueue<int> queue = new MyLinkQueue<int>();
            Console.WriteLine("Is Empty:{0}", queue.IsEmpty());
            Random rand = new Random();
            // 順序插入5個元素
            for (int i = 0; i < 5; i++)
            {
                int num = rand.Next(1, 10);
                queue.EnQueue(num);
                Console.WriteLine("{0} enqueue.", num);
            }
            Console.WriteLine("Size:{0}", queue.Size);
            Console.WriteLine("-------------------------");
            // 5個元素依次出隊
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("{0} dequeue.", queue.DeQueue());
            }
            Console.WriteLine("Size:{0}", queue.Size);
            Console.WriteLine("-------------------------");
            // 順序插入10個元素
            for (int i = 0; i < 10; i++)
            {
                int num = rand.Next(1, 10);
                queue.EnQueue(num);
                Console.WriteLine("{0} enqueue.", num);
            }
            Console.WriteLine("Size:{0}", queue.Size);
            Console.WriteLine("-------------------------");
            // 10個元素依次出隊
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("{0} dequeue.", queue.DeQueue());
            }
            Console.WriteLine("Size:{0}", queue.Size);
        }
        #endregion

        #region Method02.基於數組的隊列的測試
        /// <summary>
        /// 基於數組的隊列的測試
        /// </summary>
        static void QueueWithArrayTest()
        {
            MyArrayQueue<int> queue = new MyArrayQueue<int>(5);
            Console.WriteLine("Is Empty:{0}", queue.IsEmpty());
            Console.WriteLine("Size:{0}", queue.Size);

            Random rand = new Random();
            // Test1.1:順序插入5個數據元素
            for (int i = 0; i < 5; i++)
            {
                int num = rand.Next(1, 10);
                queue.EnQueue(num);
                Console.WriteLine("{0} enqueue.", num);
            }
            Console.WriteLine("Is Empty:{0}", queue.IsEmpty());
            Console.WriteLine("Size:{0}", queue.Size);
            // Test1.2:臨時插入1個數據元素驗證數組是否擴容
            queue.EnQueue(rand.Next(1, 20));
            Console.WriteLine("Size:{0}", queue.Size);
            Console.WriteLine("-------------------------");
            // Test2.1:前5個元素出隊
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("{0} dequeue.", queue.DeQueue());
            }
            Console.WriteLine("Is Empty:{0}", queue.IsEmpty());
            Console.WriteLine("Size:{0}", queue.Size);
            Console.WriteLine("-------------------------");
            // Test2.2:最后一個數據元素出隊驗證數組是否收縮容量
            queue.DeQueue();
            Console.WriteLine("Size:{0}", queue.Size);
            Console.WriteLine("-------------------------");
            queue.DeQueue();
        }
        #endregion
    }