C#实现顺序队列和链队列的代码实例

针对“C#实现顺序队列和链队列的代码实例”的完整攻略，我将逐一进行讲解，分别包含如下几个部分：

1. 简述队列的概念和特点；
2. 实现顺序队列的代码解析及样例说明；
3. 实现链队列的代码解析及样例说明。

1. 队列的概念和特点

队列是一种常用的数据结构，它的特点是先进先出（FIFO）。

它的基本操作有两个：入队和出队。其中入队是在队列尾插入一个元素，而出队是在队列头删除一个元素。

队列常用于对数据进行排队、如消息队列、任务队列等。

2. 实现顺序队列的代码解析及样例说明

顺序队列是队列的一种实现方式。它的结构类似于数组，但是具有固定的大小和操作的约束，即只能在队尾插入元素，在队头删除元素。

以下是一个实现顺序队列的C#代码：

public class SeqQueue<T>
{
    private T[] elements;
    private int front; 
    private int rear;
    private int capacity;

    public SeqQueue(int size)
    {
        this.elements = new T[size];
        this.front = 0;
        this.rear = 0;
        this.capacity = size;
    }

    public void EnQueue(T element)
    {
        if (IsFull())
        {
            throw new Exception("Queue is full!");
        }

        elements[rear] = element;
        rear = (rear + 1) % capacity;
    }

    public T DeQueue()
    {
        if (IsEmpty())
        {
            throw new Exception("Queue is empty!");
        }

        T element = elements[front];
        front = (front + 1) % capacity;
        return element;
    }

    public bool IsEmpty()
    {
        return front == rear;
    }

    public bool IsFull()
    {
        return (rear + 1) % capacity == front;
    }
}

其中，SeqQueue类是一个泛型类，可以使用不同的类型创建不同类型的队列。

顺序队列的核心在于 EnQueue和 DeQueue方法，分别是元素的入队和出队操作。

在 EnQueue方法中，我们首先要判断队列是否已满，如果已满则抛出队列已满的异常，否则就将要插入的元素在队尾进行插入操作。

在 DeQueue方法中，我们首先判断队列是否为空，如果为空则抛出队列为空的异常，否则就从队头进行删除操作，并返回被删除的元素。

同时，我们还需要实现 IsEmpty和 IsFull方法，分别判断队列是否为空和是否已满。

接下来我们看看一个使用顺序队列的例子，用一个基本的场景来说明。

SeqQueue<int> queue1 = new SeqQueue<int>(10);

for (int i = 0; i < 10; i++)
{
    queue1.EnQueue(i);
}

while (!queue1.IsEmpty())
{
    Console.WriteLine(queue1.DeQueue());
}

这段代码通过SeqQueue创建了一个大小为10的顺序队列，然后将元素0-9依次插入队列。最后通过DeQueue方法依次将队列中的元素取出并输出。

3. 实现链队列的代码解析及样例说明

链队列是另一种实现队列的方式。采用链式存储结构，可以动态改变队列长度。

以下是一个实现链队列的C#代码：

public class LinkedQueue<T>
{
    private Node<T> front;
    private Node<T> rear;

    public LinkedQueue()
    {
        front = null;
        rear = null;
    }

    public void EnQueue(T element)
    {
        Node<T> newNode = new Node<T>(element);

        if (IsEmpty())
        {
            front = newNode;
            rear = newNode;
        }
        else
        {
            rear.Next = newNode;
            rear = newNode;
        }
    }

    public T DeQueue()
    {
        if (IsEmpty())
        {
            throw new Exception("Queue is empty!");
        }

        T element = front.Data;
        front = front.Next;
        if (front == null)
        {
            rear = null;
        }
        return element;
    }

    public bool IsEmpty()
    {
        return front == null;
    }

    public class Node<T>
    {
        public T Data;
        public Node<T> Next;

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

其中，LinkedQueue也是一个泛型类，在构造方法中将front和rear都设置为null。

在EnQueue方法中，我们首先新建一个节点，并判断队列是否为空。因为队列为空时front和rear都为null，所以此时要将新建的节点同时赋值给front和rear。

否则，我们需要将新节点追加到队尾，并将其设置为最新的rear节点。

在 DeQueue方法中，我们首先要判断队列是否为空，如果为空则抛出队列为空的异常，否则就从队头进行删除操作，并返回被删除的元素。

同时，我们还需要实现 IsEmpty方法，判断队列是否为空。

接下来我们看看一个使用链队列的例子，用一个基本的场景来说明。

LinkedQueue<string> queue2 = new LinkedQueue<string>();

queue2.EnQueue("A");
queue2.EnQueue("B");
queue2.EnQueue("C");

while (!queue2.IsEmpty())
{
    Console.WriteLine(queue2.DeQueue());
}

这段代码通过 LinkedQueue创建了一个空队列，然后依次插入"A"、"B"、"C"三个元素。最后通过 DeQueue方法依次将队列中的元素取出并输出。

至此，这就是完整的“C#实现顺序队列和链队列的代码实例”的攻略。