C#——实现泛型顺序栈和链栈

使用C#进行了泛型栈的实现，内部以List<>作为储存器；

    class CStack<T>
    {
        int p_Index;
        List<T> list;
        //构造方法
        public CStack()
        {
            list = new List<T>();
            p_Index = -1;
        }
        public int Count
        {
            get { return list.Count; }
        }
        //入栈
        public void Push(T item)
        {
            list.Add(item);
            p_Index++;
        }
        //出栈
        public T Pop()
        {
            if (list.Count>0)
            {
                T top;
                top = list[list.Count - 1];
                list.RemoveAt(list.Count - 1);
                p_Index--;
                return top;
            }
            else
            {
                return default(T);
            }          
        }
        //Peek
        public T Top()
        {
            if (list.Count > 0)
            {
                return list[list.Count - 1];
            }
            else
            {
                return default(T);
            }                 
        }
        public void Clear()
        {
            list.Clear();
            p_Index = -1;
        }
    }

链栈，以LinkNode作为链表结点；

链栈实质上是只允许在尾部进行删除和插入的单链表；

 //链栈,这里泛型T实际为结点内的data类型
    class LinkStack<T>
    {
        private LinkNode<T> top; //top结点，处于栈顶
        private int nodeCount;  //结点数
        //构造方法
        public LinkStack()
        {
            top = null;
            nodeCount = 0;
        }
        public int Count
        {
            get { return nodeCount; }
        }
        //入栈
        public void Push(T pushNode)
        {
            LinkNode<T> p = new LinkNode<T>(pushNode);
            if (top == null)
            {
                top = p; //当栈空时，入栈结点直接作为top
            }
            else
            {
                p.Next = top;
                top = p;
            }
            nodeCount++;
        }
        //出栈，并返回栈顶元素
        public T Pop()
        {
            if (IsEmpty)
            {
                Console.WriteLine("栈元素为空");
                return default(T);
            }
            else
            {
                T topData = top.Data;
                top=top.Next;  //top结点向下移动
                nodeCount--;
                return topData;
            }
        }
        //返回栈顶元素
        public T Top()
        {
            if (IsEmpty)
                return default(T);
            else
            {
                return top.Data;
            }
        }
        //清空栈
        public void Clear()
        {
            top = null;
            nodeCount = 0;
        }
        //栈是否为空
        public bool IsEmpty
        {
            get { return (top == null&&nodeCount==0); }
        }
        //遍历输出栈元素
        public void ShowAllItem()
        {
            LinkNode<T> p = top;
            while (p!=null)
            {
                Console.WriteLine(p.Data);
                p = p.Next;
            }
        }
    }
    //---------------------------------
       //链式结构结点类
    public class LinkNode<T>
    {
        private T data;
        private LinkNode<T> next;
        //构造方法
        public LinkNode(T value,LinkNode<T> nextNode)
        {
            data = value;
            next = nextNode;
        }
        //构造方法只包含数据域的结点
        public LinkNode(T value)
        {
            data = value;
            next = null;
        }
        public T Data
        {
            get { return data; }
            set { data = value; }
        }
        public LinkNode<T> Next
        {
            get { return next; }
            set { next = value; }
        }
    }