浅析数据结构系列（三）

话不多说，继续介绍我们的数据结构常用的—栈

栈(Stack)是操作限定在表的尾端进行的线性表。表尾由于要进行插入、删除等操作，所以，它具有特殊的含义，把表尾称为栈顶（ Top），另一端是固定的，叫栈底（ Bottom）。当栈中没有数据元素时叫空栈(Empty Stack)。
栈通常记为： S= (a1,a2,…,an)，S是英文单词stack的第 1 个字母。a1为栈底元素，an为栈顶元素。这n个数据元素按照a1,a2,…,an的顺序依次入栈，而出栈的次序相反，an第一个出栈，a1最后一个出栈。所以，栈的操作是按照后进先出(Last In First Out，简称LIFO)或先进后出(First In Last Out，简称FILO)的原则进行的，因此，栈又称为LIFO表或FILO表。

• 顺序栈的实现

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

namespace Stack
{
    public interface IStackD<T>
    {
        /// <summary>
        /// 取得栈数据元素的个数
        /// </summary>
        int Count { get; }

        /// <summary>
        /// 栈元素的长度
        /// </summary>
        /// <returns></returns>
        int GetLength();

        /// <summary>
        /// 判断栈是否为空
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();

        /// <summary>
        /// 清空栈元素
        /// </summary>
        void Clear();

        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="item"></param>
        void Push(T item);

        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns></returns>
        T Pop();

        /// <summary>
        /// 返回栈元素
        /// </summary>
        /// <returns></returns>
        T Peek();
    }
}

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

namespace Stack
{
    /// <summary>
    /// 顺序栈实现的方式
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SeqStack<T> : IStack<T>
    {

        private T[] data;//存储数据
        private int top = -1;//用来指向栈顶索引的指针


        public SeqStack() : this(10)
        {

        }

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


        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++;
        }
    }
}

• 链栈的实现

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

namespace Stack
{
    /// <summary>
    /// 链栈的结点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Node<T>
    {
        private T data;
        private Node<T> next;

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

        }

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

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

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

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

        }

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

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

namespace Stack
{
    /// <summary>
    /// 链栈的实现
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LinkStack<T> : IStack<T>
    {
        /// <summary>
        /// 栈顶元素结点
        /// </summary>
        private Node<T> top = null;

        /// <summary>
        /// 栈中的元素的个数
        /// </summary>
        private int count = 0;

        public int Count
        {
            get { return count; }
        }

        public void Clear()
        {
            top = null;
            count = 0;

        }

        public int GetLength()
        {
            return count;
        }

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

        public T Peek()
        {
            return top.Data;
        }


        public T Pop()
        {
            T data = top.Data;
            top = top.Next;
            count--;
            return data;
        }

        public void Push(T item)
        {
            //把新添加的元素作为栈顶的元素（头结点）
            Node<T> newNode = new Node<T>(item);
            newNode.Next = top;
            top = newNode;
            count++;
        }
    }
}