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方法。由于使用的泛型，因此这应该是一个通用的排序方法，有两种方法可以实现：接口和委托，以后再写。