C#算法从入门到跑路 第1章：线性表之栈

栈

描述

受限的线性表，仅仅允许在一段进行插入与删除

特性

先进后出，后进先出

卡塔兰数

对于n个数合法的出栈序列

栈接口

/// <summary>
/// 栈
/// </summary>
namespace DataStruct.Stack
{
    /// <summary>
    /// 栈接口
    /// </summary>
    interface IStack<T>
    {
        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns>返回出栈元素</returns>
        public T Pop();
        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="val">入栈元素</param>
        public void Push(T val);
        /// <summary>
        /// 栈内元素个数
        /// </summary>
        public int Count { get;}
        /// <summary>
        /// 获取栈顶
        /// </summary>
        /// <returns>栈顶元素</returns>
        public T GetTop();
        /// <summary>
        /// 判断栈空
        /// </summary>
        /// <returns>返回栈是否空</returns>
        public bool IsEmpty();
        /// <summary>
        /// 清理栈内元素
        /// </summary>
        public void Clear();
        /// <summary>
        /// 转为数字
        /// </summary>
        /// <returns>返回数组</returns>
        public T[] ToArray();
    }
}

顺序栈的基本实现

/// <summary>
/// 栈
/// </summary>
namespace DataStruct.Stack
{
    /// <summary>
    /// 顺序栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class SeqStack<T> : IStack<T>, IEnumerable<T>
    {
        /// <summary>
        /// 默认栈大小
        /// </summary>
        private int DEFAULT_SIZE = 15;
        /// <summary>
        /// 数据域
        /// </summary>
        private T[] data;
        /// <summary>
        /// 栈顶
        /// </summary>
        private int top;
        /// <summary>
        /// 栈构造器
        /// </summary>
        public SeqStack()
        {
            this.data = new T[DEFAULT_SIZE];
            this.top = 0;
        }
        /// <summary>
        /// 栈构造器
        /// </summary>
        /// <param name="data">数据域</param>
        public SeqStack(params T[]data)
        {
            this.data = data;
            this.top = data.Length;
        }
        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns>返回出栈元素</returns>
        public T Pop()
        {
            if (IsEmpty())
                throw new IndexOutOfRangeException("栈空");
            return this.data[--this.top];
        }
        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="val">入栈元素</param>
        public void Push(T val)
        {
            this.data[this.top++]=val;
        }
        /// <summary>
        /// 栈内元素个数
        /// </summary>
        public int Count { get=>this.top; }
        /// <summary>
        /// 获取栈顶
        /// </summary>
        /// <returns>栈顶元素</returns>
        public T GetTop()
        {
            if (IsEmpty())
                throw new IndexOutOfRangeException("栈空");
            return this.data[this.top];
        }
        /// <summary>
        /// 判断栈空
        /// </summary>
        /// <returns>返回栈是否空</returns>
        public bool IsEmpty() => this.top == -1;
        /// <summary>
        /// 清理栈内元素
        /// </summary>
        public void Clear() => this.top = -1;
        /// <summary>
        /// 转为数组
        /// </summary>
        /// <returns>返回数组</returns>
        public T[] ToArray()=>this.data;

        public IEnumerator<T> GetEnumerator()
        {
            for (int i = this.top-1; i >= 0; --i)
                yield return this.data[i];
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            for (int i = this.top-1; i >= 0; --i)
                yield return this.data[i];
        }
    }
}

链栈的基本实现

/// <summary>
/// 栈
/// </summary>
namespace DataStruct.Stack
{
    /// <summary>
    /// 链栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class LinkStack<T> : IStack<T>, IEnumerable<T>
    {
        /// <summary>
        /// 首节点
        /// </summary>
        private Node<T> first;
        /// <summary>
        /// 节点数量
        /// </summary>
        private int count;
        /// <summary>
        /// 构造器
        /// </summary>
        public LinkStack()
        {
            this.first = new Node<T>();
        }
        /// <summary>
        /// 节点数量属性
        /// </summary>
        public int Count =>this.count;
        /// <summary>
        /// 清理
        /// </summary>
        public void Clear()
        {
            this.first.Next=new Node<T>();
            this.count = 0;
        }

        /// <summary>
        /// 取栈顶元素
        /// </summary>
        /// <returns></returns>
        public T GetTop()
        {
            if (IsEmpty())
                throw new IndexOutOfRangeException("栈空");
            return this.first.Next.Data;
        }
        /// <summary>
        /// 判断栈空
        /// </summary>
        /// <returns>返回是否空</returns>
        public bool IsEmpty() => this.count == 0;
        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns>返回出栈元素</returns>
        public T Pop()
        {
            if (IsEmpty())
                throw new IndexOutOfRangeException("栈空");
            Node<T> t = this.first.Next;
            var temp = t.Data;
            first.Next = t.Next;
            this.count--;
            return temp;
        }
        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="val">入栈元素</param>
        public void Push(T val)
        {
            Node<T> t = new Node<T>(val,first.Next);
            this.first.Next = t;
            this.count++;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            Node<T> p = this.first;
            while(p!=null)
            {
                p = p.Next;
                yield return p.Data;
            }
        }
        public IEnumerator<T> GetEnumerator()
        {
            Node<T> p = this.first;
            while (p != null)
            {
                p = p.Next;
                yield return p.Data;
            }
        }

    }
}

共享栈

/// <summary>
/// 栈
/// </summary>
namespace DataStruct.Stack
{
    /// <summary>
    /// 共享栈
    /// </summary>
    /// <typeparam name="T">数据类型</typeparam>
    class Sharetack<T>
    {
        private const int DEFAULT_SIZE = 15;
        /// <summary>
        /// 数据域
        /// </summary>
        private T[]data;
        /// <summary>
        /// 栈指针1
        /// </summary>
        private int top1;
        /// <summary>
        /// 栈指针2
        /// </summary>
        private int top2;
        /// <summary>
        /// 构造器
        /// </summary>
        public Sharetack(int size=DEFAULT_SIZE)
        {
            this.data = new T[size];
            this.top1 = 0;
            this.top2 = size;
        }
        /// <summary>
        /// 出栈1
        /// </summary>
        /// <returns>返回出栈元素</returns>
        public T Pop1()
        {
            if(IsEmpty1())
                throw new IndexOutOfRangeException("栈1空");
            return this.data[--this.top1];
        }
        /// <summary>
        /// 出栈2
        /// </summary>
        /// <returns>返回出栈元素</returns>
        public T Pop2()
        {
            if (IsEmpty2())
                throw new IndexOutOfRangeException("栈2空");
            return this.data[this.top2++];
        }
        /// <summary>
        /// 入栈1
        /// </summary>
        /// <param name="val">入栈元素</param>
        public void Push1(T val)
        {
            if (IsFull1())
                throw new IndexOutOfRangeException("栈1满");
            this.data[this.top1++] = val;
        }
        /// <summary>
        /// 入栈2
        /// </summary>
        /// <param name="val">入栈元素</param>
        public void Push2(T val)
        {
            if (IsFull2())
                throw new IndexOutOfRangeException("栈2满");
            this.data[--this.top2] = val;
        }
        /// <summary>
        /// 栈1元素个数
        /// </summary>
        public int Count1 { get=>this.top1; }
        /// <summary>
        /// 栈2元素个数
        /// </summary>
        public int Count2 { get => this.data.Length-this.top2; }
        /// <summary>
        /// 获取栈顶1
        /// </summary>
        /// <returns>栈顶元素</returns>
        public T GetTop1()
        {
            if (IsEmpty1())
                throw new IndexOutOfRangeException("栈1空");
            return  this.data[this.top1 - 1];
        }
        /// <summary>
        /// 获取栈顶2
        /// </summary>
        /// <returns>栈顶元素</returns>
        public T GetTop2()
        {
            if (IsEmpty2())
                throw new IndexOutOfRangeException("栈2空");
            return this.data[this.top2];
        }
        /// <summary>
        /// 判断栈1空
        /// </summary>
        /// <returns>返回栈1是否空</returns>
        public bool IsEmpty1() => this.top1 == 0;
        /// <summary>
        /// 判断栈2空
        /// </summary>
        /// <returns>返回栈2是否空</returns>
        private bool IsEmpty2() => this.top2 == this.data.Length;
        /// <summary>
        /// 判断栈1满
        /// </summary>
        /// <returns>返回是否满</returns>
        public bool IsFull1() => this.top1 + 1 == this.top2;
        /// <summary>
        /// 判断栈2满
        /// </summary>
        /// <returns>返回是否满</returns>
        public bool IsFull2() => this.top2 - this.top1 == 1;
        /// <summary>
        /// 清理栈内元素
        /// </summary>
        public void Clear()
        {
            this.top1 = 0;
            this.top2 = this.data.Length;
        }
    }
}