C#实现栈和队列

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StackAndQueue
{
    class Program
    {
        static void Main(string[] args)
        {
            //定义栈
            MyStack<string> myStack = new MyStack<string>();
            //定义队
            MyQueue<string> myQueue = new MyQueue<string>();

            myStack.Push("one");
            myStack.Push("two");
            myStack.Push("three");
            myStack.Push("four");
            myStack.Push("five");
            Console.WriteLine(myStack.Count);
            //出five
            Console.WriteLine(myStack.Pop());
            Console.WriteLine(myStack.Count);
            //出four
            Console.WriteLine(myStack.Pop());
            Console.WriteLine(myStack.Count);
            //出three
            Console.WriteLine(myStack.Pop());
            Console.WriteLine(myStack.Count);
            //出two
            Console.WriteLine(myStack.Pop());
            Console.WriteLine(myStack.Count);
            //出one
            Console.WriteLine(myStack.Pop());
            Console.WriteLine(myStack.Count);
            //判空
            Console.WriteLine(myStack.Pop());
            Console.WriteLine(myStack.Count);

            //myQueue.EnQue("one");
            //myQueue.EnQue("two");
            //myQueue.EnQue("three");
            //myQueue.EnQue("four");
            //myQueue.EnQue("five");
            //Console.WriteLine(myQueue.Count);
            ////出one
            //Console.WriteLine(myQueue.DeQue());
            //Console.WriteLine(myQueue.Count);
            ////出two
            //Console.WriteLine(myQueue.DeQue());
            //Console.WriteLine(myQueue.Count);
            ////出three
            //Console.WriteLine(myQueue.DeQue());
            //Console.WriteLine(myQueue.Count);
            ////出four
            //Console.WriteLine(myQueue.DeQue());
            //Console.WriteLine(myQueue.Count);
            ////出five
            //Console.WriteLine(myQueue.DeQue());
            //Console.WriteLine(myQueue.Count);
            ////判空
            //Console.WriteLine(myQueue.DeQue());
            //Console.WriteLine(myQueue.Count);

        }

        //结点类
        public class Node<T>
        {
            public T data;
            public Node<T> next;

            public T Data
            {
                get
                {
                    return data;
                }
                set
                {
                    data = value;
                }
            }

            public Node<T> Next
            {
                get
                {
                    return next;
                }
                set
                {
                    next = value;
                }
            }

            public Node(T data)
            {
                this.data = data;
                next = null;
            }
        }

        // 抽象一个简单父类
        // 为栈和队列提取一些通用的成员，抽象出一个父类，此处用接口还是抽象函数？
        // 在C#中Stack和Queue继承自两个接口：IEnumerable<T>, ICollection。
        // 但是作为简单的实现（特别是作为面试题答案），还是写成抽象类比较好，原因有二：
        // 1. 可以在抽象类中实现一些通用方法，子类只需要继承就可以直接用，可以简化代码。
        // 2. 抽象出来的父类，和子类Stack、Queue可以看做“is-a”的关系。
        // 当然也可以是非抽象的普通类，但是处于“不能实例化”的考虑，应该是抽象的
        public abstract class AbstrackList<T>
        {
            //当前节点个数
            protected int count;

            //头节点，其后才是第一个节点
            //应该为proteced，对外不可见
            protected Node<T> Head { get; set; }

            //尾节点，即最后一个节点
            protected Node<T> Tail { get; set; }

            //当前节点个数，只读
            public int Count
            {
                get
                {
                    return count;
                }
            }

            //构造函数，初始化头节点和节点个数
            protected AbstrackList()
            {
                Head = new Node<T>(default(T));
                Tail = Head;
                count = 0;
            }

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

            //“出”的操作，对于栈和队是一样的，可以卸载父类里
            //tip：应该从“头”出
            //“头”出：时间复杂度为O(1)；
            //“尾”出：时间复杂度为O(n)；
            protected T Out()
            {
                //判空
                if (Head.Next == null || count == 0)
                {
                    Console.WriteLine("Is empty!");
                    return default(T);
                }
                Node<T> outNode = Head.Next;
                Head.Next = outNode.Next;
                count--;
                return outNode.Data;
            }

            //对于“入”的操作，栈和队是有区别的，所以定义抽象方法
            protected abstract void In(T nodeData);
        }

        //实现栈
        public class MyStack<T> : AbstrackList<T>
        {
            //实现“入栈”的方法
            protected override void In(T nodeData)
            {
                Node<T> node = new Node<T>(nodeData);
                node.Next = Head.Next;
                Head.Next = node;
                count++;
            }

            //入栈
            public void Push(T nodeData)
            {
                In(nodeData);
            }

            //出栈
            public T Pop()
            {
                return Out();
            }
        }

        //实现队
        public class MyQueue<T> : AbstrackList<T>
        {
            //实现“入队”的方法
            protected override void In(T nodeData)
            {
                Node<T> node = new Node<T>(nodeData);
                Tail.Next = node;
                Tail = node;
                count++;
            }

            //入队
            public void EnQue(T nodeData)
            {
                In(nodeData);
            }

            //出队
            public T DeQue()
            {
                return Out();
            }
        }
    }
}