C#数据结构(Queue)

一、属性和接口

 interface IMQueue<T>
{
    int Size { get; }
    void Enqueue(T data);
    T Dequeue();
    bool Contains(T data);
    void Clear();
    void Print();
}

二、顺序存储

class MQueueSQ<T> : IMQueue<T>
{
    T[] _array;
    private int _head;
    private int _tail;
    private int _size;
    private const int DefaultCapacity = 4;

    private int Capacity
    {
        get { return _array.Length; }
    }

    public int Size 
    { 
        get { return _size; }
    }

    public MQueueSQ()
    {
        _head = 0; _tail = 0;
        _size = 0;
        _array = new T[_size];
    }

    private void EnsureCapacity(int size) 
    {
        if (size <= _array.Length) return;

        int capacity = _array.Length;
        int newCapacity = capacity ==0 ? DefaultCapacity : capacity * 2;
        newCapacity = newCapacity > Array.MaxLength ? Array.MaxLength : newCapacity;
        newCapacity = size > newCapacity ? size : newCapacity;

        //复制数据到新开辟的空间
        T[] newArray = new T[newCapacity];
        for(int i = 0; i < _size; i++)
        {
            T temp = _array[(i + _head) % _size];
            newArray[i] = temp;
        }
        _array = newArray;
        _head = 0;
        _tail = _size - 1;
    }

    public void Enqueue(T data)
    {
        //判断容量是否足够，不够就扩容
        EnsureCapacity(_size + 1);
        //队尾入队
        _tail = _size == 0 ? 0 : ((++_tail) % Capacity);
        _array[_tail] = data;
        _size++;
    }
    public T Dequeue()
    {
        if (_size <= 0) return default(T);

        //队头出队
        T data = _array[_head];//脏数据保留也可以，不用特意清除掉，有效数据认头尾指针
        _size--;
        _head = ++_head % Capacity;
        return data;
    }

    public bool Contains(T data)
    {
        for(int i= 0; i < _size; i++)
        {
            T temp = _array[(i+_head)%Capacity];
            if (temp.Equals(data)) return true;
        }

        return false;
    }

    public void Clear()
    {
        _array = new T[0];
        _head = _tail = 0;
        _size = 0;
    }

    public void Print() 
    {
        for (int i = 0; i < _size; i++)
        {
            T temp = _array[(i + _head) % Capacity];
            Console.Write(temp + " ");
        }
        Console.WriteLine();
    }
}

三、链式存储

//链式存储 单链表 Queue/
class MQueueLK<T> : IMQueue<T>
{
    class LinkNode
    {
        T _data;
        LinkNode _next;

        public T Data { get { return _data; } set { _data = value; } }
        public LinkNode Next { get { return _next; }set { _next = value; } }

        public LinkNode()
        {
            _data = default(T);
            _next = null;
        }
    }
    private LinkNode _head;//头指针不放数据
    private LinkNode _tail;
    private int _size;

    public int Size => _size;

    public MQueueLK()
    {
        LinkNode node = new LinkNode();
        _head = node;
        _tail = node;
        _size = 0;
    }

    //队尾入队
    public void Enqueue(T data)
    {
        LinkNode node = new LinkNode();
        node.Data = data;
        node.Next = null;
        _tail.Next = node;
        _tail = node;

        _size++;
    }
    //队头出队
    public T Dequeue()
    {
        if (_size <= 0) return default(T);
        
        LinkNode node = _head.Next;
        T data = node.Data;
        _head.Next = node.Next;

        _size--;
        return data;
    }

    public bool Contains(T data)
    {
        LinkNode node = _head.Next;
        while(node!=null && node != _tail)
        {
            if(node.Data.Equals(data)) return true;
            node = node.Next;
        }

        return false;
    }

    public void Clear()
    {
        _head = null;
        _tail = null;
        _size = 0;
    }

    public void Print()
    {
        LinkNode node = _head.Next;
        while (node != null && node != _tail)
        {
            Console.Write(node.Data + " ");
            node = node.Next;
        }
    }
}