隊列是一種特殊的線性表，特殊之處在于它只允許在表的前端（front）進行刪除操作，而在表的后端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。隊列分為順序隊列和循環隊列兩種，4種隊列實現方式，分別為：順序隊列、循環隊列、鏈表隊列和數組隊列。

下面我們一一來看4種隊列實現方式：

1.順序隊列

using System;

public class QueueLine<T>: IQueue<T>

{

    private int count;

    private int front;

    private int rear;

    public T[] data;

    public int size;

    public QueueLine(int size)

    {

        data = new T[size];

        this.size = size;

        count = 0;

        front = -1;

        rear = -1;

    }

    //默認創建10個

    public QueueLine() : this(10)

    {

    }

    public int Count

    {

        get =>count;

    }

    public int Size

    {

        get => size;

    }

    public int GetLength()

    {

        return count;

    }

    public bool IsEmpty()

    {

        return count == 0;

    }

    public void Clear()

    {

        count = 0;

        front = rear = -1;

    }

    public bool IsFull()

    {

        return count == size;

    }

    public void EnQueue(T elem)

    {

        if (IsFull())

        {

            Console.WriteLine("隊列已滿");

            return;

        }

        data[++rear] = elem;

        count++;

    }

    public T DeQueue()

    {

        if (count > 0)

        {

            T temp = data[front + 1];

            front++;

            count--;

            return temp;

        }

        else

        {

            Console.WriteLine("隊列為空，無法取得隊首元素");

            return default(T);

        }

    }

    public T Peek()

    {

        if (IsEmpty())

        {

            Console.WriteLine("隊列為空，無法取得隊首元素");

            return default(T);

        }

        return data[front + 1];

    }

}

2.循環隊列

using System;

public class QueueLoop<T> : IQueue<T>

{

    private int maxSize; //循環隊列的容量

    private T[] data; //數組，存儲數據元素

    private int front; //指示最近一個已經離開隊列的元素所占有的位置  循環順序隊列的對頭

    private int rear; //指示最近一個進入隊列的元素的位置  循環順序隊列的隊尾

    public T this[int index]

    {

        get { return data[index]; }

        set { data[index] = value; }

    }

    public int MaxSize

    {

        get => maxSize;

        set => maxSize = value;

    }

    public int Front

    {

        get => front;

        set => front = value;

    }

    public int Rear

    {

        get => rear;

        set => rear = value;

    }

    public QueueLoop()

    {

    }

    public QueueLoop(int size)

    {

        data = new T[size];

        maxSize = size;

        front = rear = -1;

    }

    public void EnQueue(T elem)

    {

        if (IsFull())

        {

            Console.WriteLine("Queue is Full!");

            return;

        }

        rear = (rear + 1) % maxSize;

        data[rear] = elem;

    }

    public T DeQueue()

    {

        if (IsEmpty())

        {

            Console.WriteLine("Queue is Empty!");

            return default(T);

        }

        front = (front + 1) % maxSize;

        return data[front];

    }

    public T Peek()

    {

        if (IsEmpty())

        {

            Console.WriteLine("Queue is Empty!");

            return default(T);

        }

        return data[(front + 1) % maxSize];

    }

    public int GetLength()

    {

        return (rear - front + maxSize) % maxSize;

    }

    public bool IsEmpty()

    {

        return front == rear;

    }

    public void Clear()

    {

        front = rear = -1;

    }

    //判斷循環隊列是否已滿

    public bool IsFull()

    {

        return (front == -1 && rear == maxSize - 1) || (rear + 1) % maxSize == front;

    }

}

3.鏈表隊列

using System;

public class QueueLink<T> : IQueue<T>

{

    private QueueNode<T> front;

    private QueueNode<T> rear;

    private int size;

    public QueueNode<T> Front

    {

        get => front;

        set => front = value;

    }

    public QueueNode<T> Rear

    {

        get => rear;

        set => rear = value;

    }

    public int Size

    {

        get => size;

        set => size = value;

    }

    public QueueLink()

    {

        front = rear = null;

        size = 0;

    }

    public void EnQueue(T elem)

    {

        QueueNode<T> q = new QueueNode<T>(elem);

        if (IsEmpty())

        {

            front = q;

            rear = q;

        }

        else

        {

            rear.Next = q;

            rear = q;

        }

        size++;

    }

    public T DeQueue()

    {

        if (IsEmpty())

        {

            Console.WriteLine("Queue is Empty!");

            return default(T);

        }

        QueueNode<T> p = front;

        front = front.Next;

        if (front == null)

        {

            rear = null;

        }

        --size;

        return p.Data;

    }

    public T Peek()

    {

        if (IsEmpty())

        {

            Console.WriteLine("Queue is Empty!");

            return default(T);

        }

        return front.Data;

    }

    public int GetLength()

    {

        return size;

    }

    public bool IsEmpty()

    {

        return front == rear && size == 0;

    }

    public void Clear()

    {

        front = rear = null;

    }

    //由于鏈表不存在滿的情況

    public bool IsFull()

    {

        return false;

    }

}

public class QueueNode<T>

{

    private T data; //數據域

    private QueueNode<T> next; //指針域

    public QueueNode(T val, QueueNode<T> p)

    {

        data = val;

        next = p;

    }

    public QueueNode(QueueNode<T> p)

    {

        next = p;

    }

    public QueueNode(T val)

    {

        data = val;

    }

    public QueueNode()

    {

        data = default(T);

        next = null;

    }

    public T Data

    {

        get => data;

        set => data = value;

    }

    public QueueNode<T> Next

    {

        get => next;

        set => next = value;

    }

}

4.數組隊列

用 head、tail、count 分別代表隊首、隊尾、隊列中的元素個數，在 QueueStudy 實例對象構造時將數組大小初始化。class QueueStudy

{

    private int[] queue ; // 數組隊列

    private int head; // 隊首

    private int tail; // 隊尾

    private int count; // 隊列元素

    public QueueStudy(int len)

    {

        queue = new int[len];

        head = 0;

        tail = 0;

        count = 0;

    }

    public void push(int element)

    {

        if(tail== queue.length)

            System.out.println("隊列已滿，無法入隊");

        else{

            queue[tail++] = element;

            count++;

        }

    }

    public int pop()

    {

        if(tail== 0)

            return -1 ; // 這里用 -1 代表無元素可出隊

        int num = queue[head++];

        count--;

        return num;

    }

    public int peek()

    {

        if(count == 0)

            return -1 ; // 這里用 -1 代表隊首無元素

        return queue[head];

    }

    public Boolean isEmpty()

    {

        return count==0;

    }

    public int size()

    {

        return count;

    }

}

因為隊列只允許在一端插入，在另一端刪除，所以只有最早進入隊列的元素才能最先從隊列中刪除，故隊列又稱為先進先出（FIFO—first in first out）線性表。因此，在某種程度上，隊列也有著線性表的基本性質，想要了解更多的隊列相關的知識，可以觀看本站的數據結構和算法教程，快速掌握各種數據結構的知識。