C# 数据结构与算法 -栈

接口定义

    interface IStackDS<T>
    {
        int Count { get; }
        int GetLength();
        bool IsEmpty();
        void Clear();
        void Push(T item);
        T Pop();
        T Peek();
    }

顺序栈

    class SeqStack<T> : IStackDS<T>
    {
        private T[] data;
        private int Top;

        public SeqStack(int Size)
        {
            data = new T[Size];
            Top = -1;
        }

        public SeqStack():this(10)
        { }

        public int Count
        {
            get
            {
                return Top + 1;
            }
        }

        public void Clear()
        {
            Top = -1;
        }

        public int GetLength()
        {
            return Count;
        }

        public bool IsEmpty()
        {
            return Count == 0;
        }

        public T Peek()
        {
            return data[Top];
        }

        public T Pop()
        {
            T temp = data[Top];
            Top--;
            return temp;
        }

        public void Push(T item)
        {
            data[Top + 1] = item;
            Top++;
        }
    }

链栈节点

    /// <summary>
    /// 链栈节点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class Node<T>
    {
        private T data;//存储数据
        private Node<T> next;//指针 用来指向下一个元素

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

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

        public Node(T Value, Node<T> next)
        {
            this.data = Value;
            this.next = next;
        }

        public Node(Node<T> next)
        {
            this.next = next;
        }

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

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

链栈实现代码

    class LinkStack<T> : IStackDS<T>
    {
        private Node<T> Top;//栈顶元素节点
        private int count = 0;//栈中元素的个数

        /// <summary>
        /// 取得栈中元素的个数
        /// </summary>
        public int Count
        {
            get
            {
                return count;
            }
        }

        /// <summary>
        /// 清空栈中所有数据
        /// </summary>
        public void Clear()
        {
            count = 0;
            Top = null;
        }

        /// <summary>
        ///  取得栈中元素的个数
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return count;
        }

        /// <summary>
        ///  判断栈中是否有数据
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return count == 0;
        }

        /// <summary>
        ///取得栈顶元素
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            return Top.Data;
        }

        /// <summary>
        /// 取得栈顶元素，然后删除该元素
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            T temp = Top.Data;
            Top = Top.Next;
            count--;
            return temp;
        }

        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            Node<T> temp = new Node<T>(item);
            temp.Next = Top;
            Top = temp;
            count++;
        }
    }

        static void Main(string[] args)
        {
            //1、使用BCL中的Stack<T>
            //Stack<char> stack = new Stack<char>();
            //2、使用自定义顺序栈
            //IStackDS<char> stack = new SeqStack<char>();
            //3、使用自定义链栈

            stack.Push('a');
            stack.Push('b');
            stack.Push('c');//栈顶数据
            Console.WriteLine("Push a b c之后的数据个数为:" + stack.Count);
            char Temp = stack.Pop();//取得栈顶数据，并把栈顶数据删除
            Console.WriteLine("Pop之后得到的数据是:" + Temp);
            Console.WriteLine("Pop之后栈中的数据个数为:" + stack.Count);
            char Temp2 = stack.Peek();//取得栈顶数据，不删除
            Console.WriteLine("Peek之后得到的数据是:" + Temp2);
            Console.WriteLine("Peek之后栈中的数据个数为:" + stack.Count);

            stack.Clear();
            Console.WriteLine("Clear之后栈中的数据个数为:" + stack.Count);

            //Console.WriteLine("空栈的时候取得栈顶的值" + stack.Peek());//出现异常
            //当空栈的时候，不要进行Pop或Peek操作，否则会出现异常
            Console.ReadKey();

        }