C#實現簡單的棧和隊列

C#提供了棧和隊列，我們自己也可以嘗試簡單實現。
而且這可以作為一個很好的面試題，主要考察c#基礎、類的設計以及數據結構。根據不同的職位需求可以考察選擇不同的考察難度和角度。4年前我第一次參加面試並進現在的公司，職位基本是公司的最低崗位了。當時面的題目就是：實現一個棧。

簡單的實現如下（考慮到順序結構實現隊列比較麻煩，采用鏈式結構）：
PS：感謝@LoveZmJ的提醒，下面的代碼有個bug，對Test有興趣的人可以先不要看評論，玩玩“大家來找茬”~~

 

首先是結點類的實現：

 // 結點類
    // 注意應該使用泛型
    public class MyNode<T>
    {
        // 存儲的數據
        public T Data
        {
            get { return _data; }
            set { _data = value; }
        }

        // 指向下一個結點
        public MyNode<T> next { get { return _next; } set { _next = value; } }

        //構造函數，不提供無參版本
        public MyNode(T data)
        {
            _data = data;
            _next = null;
        }

        // 私有字段
        private T _data;
        private MyNode<T> _next;
    }

然后抽象一個簡單的父類：

// 為棧和隊列提取一些通用的成員，抽象出一個父類，此處用接口還是抽象函數？
    // 在C#中Stack和Queue繼承自兩個接口：IEnumerable<T>, ICollection
    // 但是作為簡單的實現（特別是作為面試題答案），還是寫成抽象類比較好，原因有二：
    // 1. 可以在抽象類中實現一些通用方法，子類只需要繼承就可以直接用，可以簡化代碼
    // 2. 抽象出來的父類，和子類Stack、Queue可以看做“is-a”的關系。
    // 當然也可以是非抽象的普通類，但是處於“不能實例化”的考慮，應該是抽象的
    // 注意使用泛型
    public abstract class AbstactList<T>
    {
        // 頭結點，其后才是第一個結點
        // 注意應該是protected，對外是不可見的
        protected MyNode<T> Header { get; set; }
        // 尾結點，即是最后一個結點
        protected MyNode<T> Tail { get; set; }
        // 當前結點個數，注意是只讀屬性

        public int NoteCount { get { return _noteCount; } }

        // 構造函數，初始化頭結點和結點個數
        public AbstactList()
        {
            // 注意此處default(T)的使用
            Header = new MyNode<T>(default(T));
            Tail = Header;
            _noteCount = 0;
        }

        // “出的操作”，對於棧和隊列都是一樣的，所以可以寫在父類里
        // 注意應該從“頭”端出，時間復雜度為O（1）
        // 如果從“尾”端出，則會造成時間復雜度為O（n）
        protected T Out()
        {
            // 注意判空，只要一個條件就可以了，將所有的條件都寫在這里可以有利於在測試的時候檢測出bug
            if (Header.next == null && _noteCount == 0 && NoteCount == 0 && IsEmpty())
            {
                throw new InvalidOperationException("Is empty!");
            }

            MyNode<T> outNode = Header.next;
            Header.next = Header.next.next;
            _noteCount--;
            return outNode.Data;
        }

        // 判空
        public bool IsEmpty()
        {
            return _noteCount == 0 ? true : false;
        }

        // 對於“出”的操作，棧和隊列是有區別的，所以申明成抽象方法
        // 到子類中去具體實現
        protected abstract void In(T NodeData);

        // 子類中還要用到，所以是Protected
        protected int _noteCount;
    }

棧的具體實現：

// 棧的實現，繼承自抽象類
    public class MyStack<T> : AbstactList<T>
    {
        // 實現“進”的方法，在“頭”端
        // 由於實現抽象類方法的當前方法默認是虛的，所以無法設為private
        protected override void In(T NodeData)
        {
            MyNode<T> Node = new MyNode<T>(NodeData);
            Node.next = Header.next;
            Header.next = Node;
            _noteCount++;
        }

        // 進棧，只是將操作改個名字
        public void Push(T NodeData)
        {
            In(NodeData);
        }

        // 出棧，只是將操作改個名字
        public T Pop()
        {
            return Out();
        }
    }

隊列的實現：

// 隊列的實現，繼承自抽象類
    public class MyQueue<T> : AbstactList<T>
    {
        // 實現“進”的方法，在“尾”端
        // 由於實現抽象類方法的當前方法默認是虛的，所以無法設為private
        protected override void In(T NodeNode)
        {
            MyNode<T> Node = new MyNode<T>(NodeNode);
            Tail.next = Node;
            Tail = Node;
            _noteCount++;
        }

        public void EnQue(T NodeData)
        {
            In(NodeData);
        }

        public T DeQue()
        {
            return Out();
        }
    }

單元測試：

 [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void StackTest()
        {
            MyStack<char> charStack = new MyStack<char>();
            Assert.IsTrue(charStack.IsEmpty());
            charStack.Push('a');
            Assert.IsFalse(charStack.IsEmpty());
            charStack.Push('b');
            Assert.AreEqual(charStack.Pop(), 'b');
            charStack.Push('c');
            Assert.AreEqual(charStack.NoteCount,2);
            Assert.AreEqual(charStack.Pop(), 'c');
            Assert.AreEqual(charStack.Pop(), 'a');
            Assert.IsTrue(charStack.IsEmpty());
            
            try
            {
                charStack.Pop();
            }
            catch (Exception ex)
            {
                Assert.IsInstanceOfType(ex,typeof(InvalidOperationException));
            }
        }

        [TestMethod]
        public void QueueTest()
        {
            MyQueue<int> intQueue = new MyQueue<int>();
            Assert.IsTrue(intQueue.IsEmpty());
            intQueue.EnQue(1);
            intQueue.EnQue(2);
            Assert.AreEqual(intQueue.DeQue(), 1);
            intQueue.EnQue(3);
            Assert.AreEqual(intQueue.NoteCount,2);
            Assert.AreEqual(intQueue.DeQue(), 2);
            Assert.AreEqual(intQueue.DeQue(), 3);
            Assert.IsTrue(intQueue.IsEmpty());

            try
            {
                intQueue.DeQue();
            }
            catch (Exception ex)
            {
                Assert.IsInstanceOfType(ex, typeof(InvalidOperationException));
            }
        }
    }

后記：
作為更高難度，還可以加一個要求：實現Sort方法。由於使用的泛型，因此這應該是一個通用的排序方法，有兩種方法可以實現：接口和委托，以后再寫。