C#数据结构－栈

理论基础：

      栈(Stack)是操作限定在表的尾端进行的线性表。表尾由于要进行插入、删除等操作，所以，它具有特殊的含义，把表尾称为栈顶（Top），另一端是固定的，叫栈底（Bottom）。当栈中没有数据元素时叫空栈(Empty Stack)。

      栈可以分为顺序栈和链栈。

      用一片连续的存储空间来存储栈中的数据元素，这样的栈称为顺序栈(Sequence Stack)。类似于顺序表，用一维数组来存放顺序栈中的数据元素。栈顶指示器top设在数组下标为0的端，top随着插入和删除而变化，当栈为空时，top=-1。

      链栈通常用单链表来表示，它的实现是单链表的简化。所以，链栈结点的结构与单链表结点的结构一样，如图3.3所示。由于链栈的操作只是在一端进行，为了操作方便，把栈顶设在链表的头部，并且不需要头结点。

 

C#实现：

     顺序栈

    1 接口

       用泛型接口来表示栈，接口中的方法成员表示基本操作

public interface IStack<T>
   {

       /// <summary>
       /// 求栈的长度
       /// </summary>
       /// <returns></returns>
       int GetLength();
       /// <summary>
       /// 判断栈是否为空
       /// </summary>
       /// <returns></returns>
       bool IsEmpty();
       /// <summary>
       /// 判断栈是否已满
       /// </summary>
       /// <returns></returns>
       bool IsFull();
       /// <summary>
       /// 清空操作
       /// </summary>
       void Clear();
       /// <summary>
       /// 入栈操作
       /// </summary>
       /// <param name="item"></param>
       void Push(T item);
       /// <summary>
       /// 出栈操作
       /// </summary>
       /// <returns></returns>
       T Pop();
       /// <summary>
       /// 取栈元素
       /// </summary>
       /// <param name="index"></param>
       /// <returns></returns>
       T GetElement(int index);

   }

     2 实现

      下面实现的代码没有经过测试，不知道正确与否，有兴趣的朋友试试。

public class SeqStack<T> : IStack<T>
    {
        private int maxsize;        //顺序栈的容量
        private T[] data;           //数组，用于存储顺序栈中的数据元素
        private int top;            //栈顶

        //索引器
        public T this[int index]
        {
            get
            {
                return data[index];
            }
            set
            {
                data[index] = value;
            }
        }
        public int MaxSize
        {
            get
             {
                 return maxsize;
            }
            set
            {
                maxsize = value;
            }
        }

        public int Top
        {
            get
            {
                return top;
            }
        }

        public SeqStack(int size)
        {
            data = new T[size];
            maxsize = size;
            top = -1;
        }

        /// <summary>
        /// 求栈的长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return top + 1;
        }
        /// <summary>
        /// 判断栈是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            if (top == -1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 判断栈是否已满
        /// </summary>
        /// <returns></returns>
        public bool IsFull()
        {
            if (top == maxsize - 1)
            {
                return true;
            }
            else
            {
                return false;
             }
        }
        /// <summary>
        /// 清空操作
        /// </summary>
       public void Clear()
        {
            top = -1;
        }
        /// <summary>
        /// 入栈操作
        /// </summary>
        /// <param name="item"></param>
       public  void Push(T item)
        {
            if (IsFull())
            {
                Console.Write("Stack is full");
                return;
            }
            data[++top] = item;
        }
        /// <summary>
        /// 出栈操作
        /// </summary>
        /// <returns></returns>
       public  T Pop()
        {
            if (IsEmpty())
            {
                Console.Write("Stack is empty");
                return default(T);
            }
            T outEle = data[top];
            --top;
            return outEle;
        }
        /// <summary>
        /// 取栈顶元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetElement(int index)
        {
            if (IsEmpty())
            {
                Console.Write("Stack is empty");
                return default(T);
            }
            if (index < 0 && index > top + 1)
            {
                Console.Write("index is error");
                return default(T);
            }
            return data[index - 1];
        }
    }

   由于链栈的操作与单链表很相似，这里就不说明代码，有兴趣的朋友可以写出来，供大家分享。

C#中的栈：

    C#2.0以下版本只提供了非泛型的Stack类，该类继承了ICollection、IEnumerable和ICloneable接口。

    C#2.0提供了泛型的Stack<T>类，该类继承了IEnumerable<T>、ICollection和IEnumerable接口，关于泛型Stack<T>类的更具体的信息，读者可参考.NET Framework的有关书籍