数据结构（C#语言版）——栈和队列

栈和队列是计算机中常用的两种数据结构，是操作受限的线性表。栈的插入和删除等操作都在栈顶进行，它是先进后出的线性表。队列的删除、查找等操作在队头进行，而插入操作在队尾进行，它是先进先出的线性表。与线性表一样，栈和队列也有顺序存储与链式存储两种方式。

栈

public interface IStack<T> {
    /// <summary>
    /// 获取栈的长度
    /// </summary>
    int Count { get; }

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

    /// <summary>
    /// 将一个数据压入栈
    /// </summary>
    /// <param name="value"></param>
    void Push(T value);

    /// <summary>
    /// 将一个数据弹出栈
    /// </summary>
    /// <returns></returns>
    T Pop();

    /// <summary>
    /// 获取栈顶部的数据，但不弹出
    /// </summary>
    /// <returns></returns>
    T Peek();
}

顺序栈

public class SequenceStack<T> : IStack<T> {
    private const int Step = 16;
    private int _capacity;
    private int _top = -1;
    private T[] _datas;

    public SequenceStack() : this(Step) {}

    public SequenceStack(int capacity) {
        this._capacity = capacity;
        this._datas = new T[this._capacity];
    }

    public int Count {
        get { return this._top + 1; }
    }

    public void Clear() {
        this._top = -1;
    }

    public void Push(T value) {
        if(this._top+1>=this._datas.Length) {
            this._capacity += Step;
            T[] temps = new T[this._capacity];
            for(int i = 0; i < this._datas.Length; i++) {
                temps[i] = this._datas[i];
            }
            this._datas = temps;
        }
        this._datas[++this._top] = value;
    }

    public T Pop() {
        return this._datas[this._top--];
    }

    public T Peek() {
        return this._datas[this._top];
    }
}

链栈

public class StackNode<T> {
    private StackNode<T> _next;
    private T _value;

    public StackNode() : this(default(T), null) {
    }

    public StackNode(T value) : this(value, null) {
    }

    public StackNode(T value, StackNode<T> next) {
        this._value = value;
        this._next = next;
    }

    public StackNode<T> Next {
        get { return this._next; }
        set { this._next = value; }
    }

    public T Value {
        get { return this._value; }
        set { this._value = value; }
    }
}

public class LinkStack<T> : IStack<T> {
    private int _count = 0;
    StackNode<T> _top;

    public int Count {
        get { return this._count; }
    }

    public void Clear() {
        this._top = null;
        this._count = 0;
    }

    public void Push(T value) {
        this._top=new StackNode<T>(value, this._top);
        this._count++;
    }

    public T Pop() {
        T result = this._top.Value;
        this._top = this._top.Next;
        this._count--;
        return result;
    }

    public T Peek() {
        return this._top.Value;
    }
}

队列

public interface IQueue<T> {
    /// <summary>
    /// 获取队列的长度
    /// </summary>
    int Count { get; }

    /// <summary>
    /// 清空队列
    /// </summary>
    void Clear();

    /// <summary>
    /// 一个数据进入队列
    /// </summary>
    /// <param name="value"></param>
    void Add(T value);

    /// <summary>
    /// 一个数据弹出队列
    /// </summary>
    /// <returns></returns>
    T Dequeue();

    /// <summary>
    /// 获取最前面的数据，但不出队列
    /// </summary>
    /// <returns></returns>
    T Peek();
}

顺序队列

public class SequenceQueue<T> : IQueue<T> {
    private const int Step = 16;
    private int _capacity;
    private int _front = -1;
    private int _rear = -1;
    private T[] _datas;

    public SequenceQueue() : this(Step) { }

    public SequenceQueue(int capacity) {
        this._capacity = capacity;
        this._datas = new T[this._capacity];
    }

    public int Count {
        get {
            if(this._front==-1 && this._rear==-1) {
                return 0;
            }
            if(this._front <= this._rear) {
                return this._rear - this._front + 1;
            }
            return this._datas.Length - this._front + this._rear + 1;
        }
    }

    public void Clear() {
        this._front = -1;
        this._rear = -1;
    }

    public void Add(T value) {
        if(this.Count==this._datas.Length) {
            this._capacity += Step;
            T[] temps = new T[this._capacity];
            for(int i = 0; i < this._datas.Length; i++) {
                temps[i] = this.Dequeue();
            }
            this._datas = temps;
            this._front = 0;
            this._rear = this._datas.Length - 1;
        }
        if(this._rear+1==this._datas.Length) {
            this._rear = 0;
        }
        else {
            this._rear++;
        }
        this._datas[this._rear] = value;
    }

    public T Dequeue() {
        if(this.Count==0) {
            throw new Exception("Queue is Empty");
        }
        T result = this._datas[this._front];
        if(this.Count==1) {
            this._front = -1;
            this._rear = -1;
        }
        else {
            if(this._front+1==this._datas.Length) {
                this._front = 0;
            }
            else {
                this._front++;
            }
        }
        return result;
    }

    public T Peek() {
        if(this.Count == 0) {
            throw new Exception("Queue is Empty");
        }
        return this._datas[this._front];
    }
}

链队列

public class QueueNode<T> {
    private QueueNode<T> _next;
    private T _value;

    public QueueNode() : this(default(T), null) {
    }

    public QueueNode(T value) : this(value, null) {
    }

    public QueueNode(T value, QueueNode<T> next) {
        this._value = value;
        this._next = next;
    }

    public QueueNode<T> Next {
        get { return this._next; }
        set { this._next = value; }
    }

    public T Value {
        get { return this._value; }
        set { this._value = value; }
    }
}

public class LinkQueue<T> : IQueue<T> {
    private int _count = 0;
    private QueueNode<T> _front;
    private QueueNode<T> _rear;

    public int Count {
        get { return _count; }
    }

    public void Clear() {
        this._count = 0;
    }

    public void Add(T value) {
        QueueNode<T> node = new QueueNode<T>(value);
        if(this._count==0) {
            this._front = this._rear = node;
        }
        else {
            this._rear.Next = node;
            this._rear = node;
        }
        this._count++;
    }

    public T Dequeue() {
        if(this.Count == 0) {
            throw new Exception("Queue is Empty");
        }
        T result = this._front.Value;
        this._front = this._front.Next;
        this._count--;
        return result;
    }

    public T Peek() {
        if(this.Count == 0) {
            throw new Exception("Queue is Empty");
        }
        return this._front.Value;
    }
}