数据结构之队列

队列的定义

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表

队列(Queue)是一种先进先出(First In First Out)的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头

队列在C#中的使用

        static void Main(string[] args)
        {
            Queue<string> queue= new Queue<string>();
            queue.Enqueue("第一个元素");//入队
            queue.Enqueue("第二个元素");//入队
            queue.Enqueue("第三个元素");//入队
            queue.Dequeue();//出队
            Console.WriteLine(queue.Peek());
            Console.ReadLine();
        }

应用
服务器排队
游戏中释放的组合技能

顺序队列
1、不实用
出队是需要移动队头后面的所有元素，时间复杂度较高
会出现假溢出的情况

循环顺序队列
循环队列的定义：将头尾相接的顺序存储结构称为循环队列

增加一个rear指针，指向队尾的下一个元素
队列空;front == rear
队列满：(rear+1)%QueueSize == front
队列长度: (rear-front+QueueSize)%QueueSize

public class MySeqQueue<T>
{
    private T[] elems;
    private int rear = 0;
    private int front = 0;

    public MySeqQueue(int maxN)
    {
        elems = new T[maxN];
    }
    public bool IsFull
    {
        get
        {
            return (rear + 1) % elems.Length == front;
        }
    }

    public bool IsNull
    {
        get
        {
            return rear == front;
        }
    }
    public int GetLength
    {
        get
        {
            return (rear - front + elems.Length) % elems.Length;
        }
    }
    public T Peek()
    {
        return elems[front];
    }

    public void Enqueue(T elem)
    {
        elems[rear] = elem;
        rear = (rear + 1) % elems.Length;
    }

    public T DeQueue()
    {
        T ret = elems[front];
        front = (front + 1) % elems.Length;
        return ret;
    }
}

 static void Main(string[] args)
        {
            MySeqQueue<string> mySeqQueue = new MySeqQueue<string>(3);
            mySeqQueue.Enqueue("第一个元素");
            mySeqQueue.Enqueue("第二个元素");
            mySeqQueue.Enqueue("第三个元素");
            mySeqQueue.DeQueue();
            mySeqQueue.DeQueue();
            Console.WriteLine(mySeqQueue.Peek()); ;
            Console.ReadLine();
        }

链队
队列的链式存储结构，实际是就是线性表的单链表，值不过它只能为尾进头出而已。

入队： 增加尾指针
出队：头部删除节点
带头结点
队空：front == rear
不带头结点
对空： front == rear == null

using System;

namespace MyLinkedQueue
{
    class Node
    {
       public Node next;
       public string data;
    }

    class LinkQueue
    {
       private  Node front;
       private Node rear;
       private int size = 0;

        public void  EnQueue(string elem)
        {
            Node insertNode = new Node();
            insertNode.data = elem;
          
            if (size == 0)
            {
                front = insertNode;
                rear = insertNode;

            }
            else 
            {
                rear.next = insertNode;
                rear = insertNode;
            }

            size++;
        }

        public string Peek()
        {
            return rear.data;
        }

        public void DeQueue()
        {
            Node p = front.next;
            front.next = p.next;
        }


    }
    class Program
    {
        static void Main(string[] args)
        {
            LinkQueue lq = new LinkQueue();
            lq.EnQueue("2");
            lq.EnQueue("1");
            lq.DeQueue();
            Console.WriteLine( lq.Peek());
            Console.ReadLine();

        }
    }
}